Telegram Web K with changes to work inside I2P https://web.telegram.i2p/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

265 lines
7.5 KiB

3 years ago
/*
* https://github.com/morethanwords/tweb
* Copyright (C) 2019-2021 Eduard Kuzmenko
* https://github.com/morethanwords/tweb/blob/master/LICENSE
*/
// #if MTPROTO_SW
3 years ago
import '../mtproto/mtproto.worker';
// #endif
3 years ago
import { logger, LogTypes } from '../logger';
import { CACHE_ASSETS_NAME, requestCache } from './cache';
import onStreamFetch from './stream';
import { closeAllNotifications, onPing } from './push';
import CacheStorageController from '../files/cacheStorage';
2 years ago
import { IS_SAFARI } from '../../environment/userAgent';
import ServiceMessagePort, { ServiceDownloadTaskPayload } from './serviceMessagePort';
import listenMessagePort from '../../helpers/listenMessagePort';
import { getWindowClients } from '../../helpers/context';
import { MessageSendPort } from '../mtproto/superMessagePort';
import noop from '../../helpers/noop';
import makeError from '../../helpers/makeError';
3 years ago
export const log = logger('SW', LogTypes.Error | LogTypes.Debug | LogTypes.Log | LogTypes.Warn);
const ctx = self as any as ServiceWorkerGlobalScope;
// #if !MTPROTO_SW
let _mtprotoMessagePort: MessagePort;
export const getMtprotoMessagePort = () => _mtprotoMessagePort;
const sendMessagePort = (source: MessageSendPort) => {
const channel = new MessageChannel();
serviceMessagePort.attachPort(_mtprotoMessagePort = channel.port1);
serviceMessagePort.invokeVoid('port', undefined, source, [channel.port2]);
3 years ago
};
const sendMessagePortIfNeeded = (source: MessageSendPort) => {
if(!connectedWindows.size && !_mtprotoMessagePort) {
sendMessagePort(source);
3 years ago
}
};
const onWindowConnected = (source: WindowClient) => {
log('window connected', source.id);
if(source.frameType === 'none') {
log.warn('maybe a bugged Safari starting window', source.id);
return;
}
sendMessagePortIfNeeded(source);
connectedWindows.add(source.id);
};
3 years ago
type DownloadType = Uint8Array;
type DownloadItem = ServiceDownloadTaskPayload & {
transformStream: TransformStream<DownloadType, DownloadType>,
readableStream: ReadableStream<DownloadType>,
writableStream: WritableStream<DownloadType>,
writer: WritableStreamDefaultWriter<DownloadType>,
// controller: TransformStreamDefaultController<DownloadType>,
// promise: CancellablePromise<void>,
used?: boolean
3 years ago
};
const downloadMap: Map<string, DownloadItem> = new Map();
const DOWNLOAD_ERROR = makeError('UNKNOWN');
3 years ago
export const serviceMessagePort = new ServiceMessagePort<false>();
serviceMessagePort.addMultipleEventsListeners({
notificationsClear: closeAllNotifications,
3 years ago
toggleStorages: ({enabled, clearWrite}) => {
CacheStorageController.toggleStorage(enabled, clearWrite);
3 years ago
},
pushPing: (payload, source) => {
onPing(payload, source);
3 years ago
},
hello: (payload, source) => {
onWindowConnected(source as any as WindowClient);
},
download: (payload) => {
const {id} = payload;
if(downloadMap.has(id)) {
return;
}
// const writableStrategy = new ByteLengthQueuingStrategy({highWaterMark: 1024 * 1024});
// let controller: TransformStreamDefaultController<DownloadType>;
const transformStream = new TransformStream<DownloadType, DownloadType>(/* {
start: (_controller) => controller = _controller,
}, {
highWaterMark: 1,
size: (chunk) => chunk.byteLength
}, new CountQueuingStrategy({highWaterMark: 4}) */);
const {readable, writable} = transformStream;
const writer = writable.getWriter();
// const promise = deferredPromise<void>();
// promise.catch(noop).finally(() => {
// downloadMap.delete(id);
// });
// writer.closed.then(promise.resolve, promise.reject);
writer.closed.catch(noop).finally(() => {
log.error('closed writer');
downloadMap.delete(id);
});
const item: DownloadItem = {
...payload,
transformStream,
readableStream: readable,
writableStream: writable,
writer,
// promise,
// controller
};
downloadMap.set(id, item);
return writer.closed.catch(() => {throw DOWNLOAD_ERROR;});
// return promise;
},
downloadChunk: ({id, chunk}) => {
const item = downloadMap.get(id);
if(!item) {
return Promise.reject();
}
// return item.controller.enqueue(chunk);
return item.writer.write(chunk);
},
downloadFinalize: (id) => {
const item = downloadMap.get(id);
if(!item) {
return Promise.reject();
}
// item.promise.resolve();
// return item.controller.terminate();
return item.writer.close();
},
downloadCancel: (id) => {
const item = downloadMap.get(id);
if(!item) {
return;
}
// item.promise.reject();
// return item.controller.error();
return item.writer.abort();
3 years ago
}
});
// * service worker can be killed, so won't get 'hello' event
getWindowClients().then((windowClients) => {
log(`got ${windowClients.length} windows from the start`);
windowClients.forEach((windowClient) => {
onWindowConnected(windowClient);
});
});
3 years ago
let connectedWindows: Set<string> = new Set();
listenMessagePort(serviceMessagePort, undefined, (source) => {
const isWindowClient = source instanceof WindowClient;
if(!isWindowClient || !connectedWindows.has(source.id)) {
return;
}
3 years ago
log('window disconnected');
connectedWindows.delete(source.id);
if(!connectedWindows.size) {
log.warn('no windows left');
if(_mtprotoMessagePort) {
serviceMessagePort.detachPort(_mtprotoMessagePort);
_mtprotoMessagePort = undefined;
}
if(downloadMap.size) {
for(const [id, item] of downloadMap) {
item.writer.abort().catch(noop);
}
}
}
});
// #endif
3 years ago
const onFetch = (event: FetchEvent): void => {
// #if !DEBUG
if(
!IS_SAFARI &&
event.request.url.indexOf(location.origin + '/') === 0 &&
event.request.url.match(/\.(js|css|jpe?g|json|wasm|png|mp3|svg|tgs|ico|woff2?|ttf|webmanifest?)(?:\?.*)?$/)
) {
3 years ago
return event.respondWith(requestCache(event));
}
// #endif
3 years ago
try {
const [, url, scope, params] = /http[:s]+\/\/.*?(\/(.*?)(?:$|\/(.*)$))/.exec(event.request.url) || [];
// log.debug('[fetch]:', event);
3 years ago
switch(scope) {
case 'stream': {
onStreamFetch(event, params);
break;
}
case 'download': {
const item = downloadMap.get(params);
if(!item || item.used) {
break;
}
item.used = true;
const response = new Response(item.transformStream.readable, {headers: item.headers});
event.respondWith(response);
break;
}
3 years ago
}
} catch(err) {
log.error('fetch error', err);
3 years ago
event.respondWith(new Response('', {
status: 500,
statusText: 'Internal Server Error',
}));
}
};
const onChangeState = () => {
ctx.onfetch = onFetch;
};
ctx.addEventListener('install', (event) => {
log('installing');
event.waitUntil(ctx.skipWaiting()); // Activate worker immediately
});
ctx.addEventListener('activate', (event) => {
log('activating', ctx);
event.waitUntil(ctx.caches.delete(CACHE_ASSETS_NAME));
event.waitUntil(ctx.clients.claim());
});
// ctx.onerror = (error) => {
// log.error('error:', error);
// };
3 years ago
// ctx.onunhandledrejection = (error) => {
// log.error('onunhandledrejection:', error);
// };
3 years ago
ctx.onoffline = ctx.ononline = onChangeState;
onChangeState();