@kirill.konshin/utils 0.0.18 → 0.0.20

package/src/core/errors.ts

@@ -1,14 +0,0 @@
-// @see https://www.youtube.com/watch?v=AdmGHwvgaVs
-export function catchErrors<T, E extends Error = Error>(promise: Promise<T>, errors?: E[]) {
-    return promise
-        .then((data) => [undefined, data])
-        .catch((error) => {
-            if (!errors?.length) {
-                return [error];
-            }
-            if (errors.some((e) => e instanceof error)) {
-                return [error];
-            }
-            throw error;
-        });
-}

package/src/core/files.ts

@@ -1,25 +0,0 @@
-export const downloadFile = async (filename, text, type = 'application/json') => {
-    //FIXME https://github.com/eligrey/FileSaver.js/issues/471
-    const { saveAs } = require('file-saver');
-
-    //FIXME https://github.com/eligrey/FileSaver.js/issues/731
-    saveAs(new Blob([text], { type }), filename);
-};
-
-export const openFile = (): Promise<string> =>
-    new Promise((res, rej) => {
-        const input = document.createElement('input');
-        input.type = 'file';
-        input.addEventListener('change', function readFile(e) {
-            input.removeEventListener('change', readFile);
-            // @ts-expect-error file is always there
-            const [file] = e.target.files;
-            if (!file) return;
-            const reader = new FileReader();
-            reader.onload = (e) => res(e.target?.result as string);
-            reader.onerror = rej;
-            reader.onabort = rej;
-            reader.readAsText(file);
-        });
-        input.click();
-    });

package/src/core/ls.ts

@@ -1,11 +0,0 @@
-export function getStorage(pref: string) {
-    const prefix = (key) => `${pref}-${key}`;
-
-    const ls = (typeof window !== 'undefined' ? localStorage : null) as Storage;
-
-    const read = (key: string) => JSON.parse(ls?.getItem(prefix(key)) || 'null');
-    const write = (key: string, value: any) => ls?.setItem(prefix(key), JSON.stringify(value));
-    const remove = (key: string) => ls?.removeItem(prefix(key));
-
-    return { read, write, remove };
-}

package/src/core/measure.ts

@@ -1,61 +0,0 @@
-import { bold, magenta, cyan, yellow, red, green } from 'colors/safe';
-
-export const colored = {
-    important: bold,
-    subject: magenta,
-    arg: cyan,
-    sup: yellow,
-    err: red,
-    ok: green,
-};
-
-const noColor = (str) => str;
-
-export const uncolored = {
-    important: noColor,
-    subject: noColor,
-    arg: noColor,
-    sup: noColor,
-    err: noColor,
-    ok: noColor,
-};
-
-export function createMeasurer({ colors = true, prepend = 'LOG', padding = 10 }) {
-    const { important, subject, arg, sup, ok, err } = colors ? colored : uncolored;
-
-    function measure(what: string, step: string, supplemental: string = '', ...args) {
-        const time = performance.now();
-
-        const prefix = [
-            prepend,
-            important(subject(what.substring(0, padding).padStart(padding, ' '))),
-            arg(step),
-            sup(supplemental),
-            ...args,
-        ];
-
-        const done = (result: string = ok('DONE'), ...args2) => {
-            console.log(
-                ...[
-                    ...prefix,
-                    important(result),
-                    ...args2,
-                    'in',
-                    important((performance.now() - time).toFixed(0)),
-                    'ms',
-                ].filter(Boolean),
-            );
-            console.groupEnd();
-        };
-
-        const fail = (result: string = err('FAIL'), ...args2) => done(result, ...args2);
-
-        const log = (...args2) => {
-            console.log(...prefix, ...args2);
-        };
-
-        return { done, fail, log };
-    }
-
-    return { measure, important, subject, arg, sup, ok, err };
-}

package/src/core/mutex.ts

@@ -1,22 +0,0 @@
-//TODO Implement queue with ranking & sorting
-//TODO https://github.com/sindresorhus/p-queue
-export class Mutex {
-    private promise = Promise.resolve();
-
-    public exec(fn: (...args: any) => any): ReturnType<typeof fn> {
-        return new Promise((resolve, reject) => {
-            // wrap in always successful function
-            this.promise = this.promise.then(async () => {
-                try {
-                    resolve(await fn());
-                } catch (e) {
-                    reject(e);
-                }
-            });
-        });
-    }
-
-    public wrap(fn: (...args: any) => any): ReturnType<typeof fn> {
-        return (...args: any) => this.exec(() => fn(...args));
-    }
-}

package/src/core/worker.test.ts

@@ -1,197 +0,0 @@
-import { expect, describe, test, vi } from 'vitest';
-import { RespondersBase, WorkerDialog } from './worker';
-import EventEmitter from 'node:events';
-
-// Prepare
-
-//TODO @vitest/web-worker can ve used, coverage is collected, but this gives more direct access to worker internals
-// class WorkerPeer extends EventEmitter implements WorkerLike {
-class WorkerPeer extends EventEmitter {
-    peer: WorkerPeer;
-
-    setPeer(peer: WorkerPeer) {
-        this.peer = peer;
-    }
-
-    postMessage(data: any) {
-        this.peer?.emit('message', { data });
-    }
-
-    addEventListener(event: string, listener: (e: any) => void, options) {
-        this[options['once'] ? 'once' : 'on'](event, listener);
-        options?.signal?.addEventListener('abort', () => this.off(event, listener));
-    }
-
-    removeEventListener(event: string, listener: (e: any) => void) {
-        this.off(event, listener);
-    }
-}
-
-class Responders extends RespondersBase<Responders> {
-    lastContext: any; // for testing purposes
-
-    test = this.create(
-        'test',
-        async (
-            { n, abort = false, buf }: { n: number; abort?: boolean; buf?: ArrayBuffer }, // should have all possible combinations for strong typing
-            ctx,
-        ) => {
-            this.lastContext = ctx;
-
-            const res: number[] = [];
-
-            let aborted = false;
-            let progress = 0;
-
-            ctx.listen(({ abort }) => {
-                if (abort) aborted = true;
-            });
-
-            for (const i of Array(n).keys()) {
-                if (aborted) break;
-                progress = (i + 1) / n;
-                ctx.send({ progress });
-                res.push(i);
-            }
-
-            return { res, progress, aborted };
-        },
-    );
-
-    error = this.create(
-        'error',
-        async (
-            _, // should have all possible combinations for strong typing
-            ctx,
-        ) => {
-            this.lastContext = ctx;
-            throw new Error('Test');
-        },
-    );
-}
-
-const createWorker = () => {
-    const mainWorker = new WorkerPeer();
-    const mainDialog = new WorkerDialog(
-        mainWorker as never as Worker,
-        {} as WorkerDialog<Responders>['responders'],
-        'Main',
-    );
-
-    const worker = new WorkerPeer();
-    const workerDialog = new WorkerDialog(worker as never as Worker, new Responders(), 'Worker');
-
-    mainWorker.setPeer(worker);
-    worker.setPeer(mainWorker);
-
-    return { mainWorker, mainDialog, worker, workerDialog };
-};
-
-// Tests
-
-describe('Worker', async () => {
-    test('simple', async () => {
-        const { mainDialog, workerDialog } = createWorker();
-
-        const l = vi.fn();
-        let mctx;
-
-        const result = await mainDialog.withMessage('test').fetch({ n: 3, buf: new ArrayBuffer() }, (ctx) => {
-            mctx = ctx;
-            ctx.listen(l);
-        });
-
-        expect(l).toBeCalledTimes(4); // 3x progress, last
-        expect(result).toStrictEqual({ res: [0, 1, 2], progress: 1, aborted: false });
-
-        expect(mainDialog.contexts.size).toBe(0);
-        expect(mctx.debugInfo.closed).toBe(true);
-
-        expect(workerDialog.contexts.size).toBe(2);
-        expect(workerDialog.contexts.values().next().value.debugInfo).toStrictEqual({
-            id: '*',
-            parentId: undefined,
-            message: 'test',
-            closed: false,
-            type: 'response',
-            listeners: 1,
-        });
-        expect(workerDialog.responders.lastContext.debugInfo).toStrictEqual({
-            id: '1',
-            parentId: '*',
-            message: 'test',
-            closed: true,
-            type: 'response',
-            listeners: 0,
-        });
-    });
-
-    test('abort', async () => {
-        const { mainDialog } = createWorker();
-
-        const result = await mainDialog.withMessage('test').fetch({ n: 3 }, (ctx) => {
-            ctx.listen(() => {
-                ctx.send({ abort: true });
-            });
-        });
-
-        expect(result).toStrictEqual({ res: [0], progress: 0.3333333333333333, aborted: true });
-    });
-
-    test('faulty listener', async () => {
-        const { mainDialog } = createWorker();
-
-        await mainDialog.withMessage('test').fetch({ n: 3 }, (ctx) => {
-            ctx.listen(() => {
-                throw new Error('Listener');
-            });
-        });
-
-        expect.assertions(0); // nothing happened
-    });
-
-    test('error', async () => {
-        const { mainDialog } = createWorker();
-        await expect(async () => mainDialog.withMessage('error').fetch()).rejects.toThrowError('Test');
-    });
-
-    test('close', async () => {
-        const { mainDialog, workerDialog } = createWorker();
-
-        mainDialog.close();
-        workerDialog.close();
-
-        expect(mainDialog.contexts.size).toBe(0);
-        expect(workerDialog.contexts.size).toBe(0);
-    });
-
-    test('empty message', async () => {
-        expect(() => createWorker().mainDialog.withMessage(undefined as any)).toThrowError(
-            'New context must have message',
-        );
-    });
-
-    test('empty ID', async () => {
-        const { mainDialog } = createWorker();
-        const first = mainDialog.withMessage('test');
-        expect(() => first.withMessage('error', '')).toThrowError('ID is required');
-    });
-
-    test('nesting', async () => {
-        const { mainDialog } = createWorker();
-        const first = mainDialog.withMessage('test');
-        const second = first.withMessage('error', 'x');
-        const third = second.withMessage('error');
-        expect(mainDialog.contexts.size).toBe(3);
-        expect(first.info).toBe('Main:*/1:test[open,request]');
-        first.close();
-        expect(mainDialog.contexts.size).toBe(0);
-        expect(first.debugInfo.closed).toBe(true);
-        expect(second.debugInfo.closed).toBe(true);
-        expect(third.debugInfo.closed).toBe(true);
-        expect(first.info).toBe('Main:*/1:test[closed,request]'); // id bumped from 0
-        expect(second.info).toBe('Main:1/x:error[closed,request]'); // new id
-        expect(third.info).toBe('Main:x/x:error[closed,request]'); // id kept
-        await expect(() => first.fetch({ n: 1 })).rejects.toThrowError(/Context 1 is closed/);
-    });
-});

package/src/core/worker.ts

@@ -1,340 +0,0 @@
-import { getTransferrable } from './workerUtils';
-
-// Types
-
-type WebWorker = Worker | (Window & typeof globalThis) | (WorkerGlobalScope & typeof globalThis);
-
-type MethodReturn<R, M extends keyof R> = R[M] extends (...args: any[]) => any
-    ? Partial<Awaited<ReturnType<R[M]>>>
-    : never;
-
-type MethodArg<R, M extends keyof R> = R[M] extends (arg: infer A, ...args: any[]) => any ? Partial<A> : never;
-
-export type Ctx<R, K extends keyof R> = {
-    id: string;
-    parentId?: string;
-    message: K;
-    done: boolean;
-};
-
-type Data<R, M extends keyof R> = MethodReturn<R, M> | MethodArg<R, M> | Error;
-
-type Event<R, M extends keyof R> = MessageEvent<{ data: Data<R, M>; ctx: Ctx<R, M> }>;
-
-type Listener<R, M extends keyof R, D extends Data<R, M> = Data<R, M>, S extends Context<R, M> = Context<R, M>> = (
-    data: D,
-    self: S,
-    event: Event<R, M>,
-) => void | Promise<void>;
-
-// Constants
-
-const ALL = '*';
-
-const RESPONDER = Symbol('responder');
-
-function checkClosed(obj: any, label: string = 'external') {
-    if (obj?.closed) throw new Error(`Context ${obj.id} is closed (${label})`, { cause: obj });
-}
-
-function checkMessage(obj: any, message: any) {
-    if (!message) throw new Error('New context must have message', { cause: obj });
-}
-
-// Classes
-
-export class WorkerDialog<R extends RespondersBase<any>> {
-    readonly contexts = new Set<Context<R, keyof R>>();
-    protected closed = false;
-    protected currentId = 0; // IDs are intentionally not global
-
-    constructor(
-        public worker: WebWorker,
-        public responders: R,
-        public name: string,
-        public debug: number = 0, // 0 - none, 1 - general messages, 2 - sub/unsub, 3 - transport TODO Object?
-    ) {
-        if (!this.worker) return; // Next.js SSR
-
-        for (const message in this.responders) {
-            if (!this.responders?.[message]?.[RESPONDER]) continue;
-
-            // root context with id=all
-            const rootContext = new ResponseContext<R, typeof message>(this, message, ALL);
-
-            //TODO: unsub(); ? Probably not needed, root must be always listening until closed by WorkerDialog
-            rootContext.listen(async (data, context, event) => {
-                // create sub context with ID
-                const responseContext = context.withMessage(message, event.data.ctx.id);
-
-                /* v8 ignore start */
-                if (this.debug)
-                    console.log('Root Listener', rootContext.info, {
-                        rootContext: context,
-                        data,
-                        responseContext,
-                        event,
-                        responder: this.responders[message],
-                    });
-                /* v8 ignore stop */
-
-                try {
-                    responseContext.send(await (this.responders[message] as any)(data, responseContext), true);
-                    responseContext.close('root.listener');
-                } catch (e) {
-                    /* v8 ignore next */
-                    if (this.debug) console.error(`Error in responder ${responseContext.info}`, { e });
-                    responseContext.send(e, true);
-                }
-            }, true);
-        }
-    }
-
-    getID() {
-        return (++this.currentId).toString();
-    }
-
-    close() {
-        for (const context of this.contexts) context.close('root');
-        this.contexts.clear();
-    }
-
-    withMessage<M extends keyof R>(message: M) {
-        return new RequestContext<R, M>(this, message, this.getID()); // always new context
-    }
-}
-
-export class RespondersBase<R> {
-    create<M extends keyof R, F extends (input: any, context: ResponseContext<R, M>) => any>(
-        message: M,
-        responder: F,
-    ): F {
-        responder[RESPONDER] = true;
-        return responder as any;
-    }
-}
-
-// can only be used to create actual contexts, carries the context data
-abstract class Context<R, M extends keyof R> {
-    protected readonly unsub = new Set<() => void>();
-    protected closed = false;
-
-    constructor(
-        protected readonly dialog: WorkerDialog<any>,
-        public message: M,
-        public id: string | undefined,
-        public parent: Context<R, keyof R> | undefined | null = null,
-    ) {
-        checkClosed(dialog, 'newContext');
-        checkClosed(parent, 'newContext');
-        checkMessage(this, message);
-        this.id = id ?? parent?.id;
-        if (!this.id) throw new Error('ID is required', { cause: this });
-        this.dialog.contexts.add(this);
-    }
-
-    abstract withMessage<M2 extends keyof R>(message: M2, id?: string): Context<R, M2>;
-
-    close(reason: string = 'external') {
-        /* v8 ignore next */
-        if (this.dialog.debug >= 2) console.log('Closing', this.info, reason, this);
-
-        this.dialog.contexts.delete(this);
-
-        // Unsubscribe from all listeners
-        for (const unsub of this.unsub) unsub();
-        this.unsub.clear();
-
-        // Remove all child contexts
-        this.dialog.contexts.forEach((context) => {
-            if (context.parent?.id === this.id) context.close('parent');
-        });
-
-        this.closed = true;
-    }
-
-    get info() {
-        return `${this.dialog.name}:${this.parent?.id ?? ALL}/${this.id}:${this.message.toString()}[${this.closed ? 'closed' : 'open'},${this.type}]`;
-    }
-
-    get debugInfo() {
-        return {
-            id: this.id,
-            parentId: this.parent?.id,
-            message: this.message,
-            closed: this.closed,
-            type: this.type,
-            listeners: this.unsub.size,
-        };
-    }
-
-    abstract type: 'request' | 'response' | string;
-
-    protected postMessage(data?: Data<R, M>, done = false) {
-        checkClosed(this, 'postMessage');
-
-        const transfer = getTransferrable(data);
-
-        const ctx = {
-            done,
-            id: this.id,
-            parentId: this.parent?.id,
-            message: this.message,
-        };
-
-        /* v8 ignore next */
-        if (this.dialog.debug >= 3) console.log('postMessage', this.info, { ctx, data, transfer }, this);
-
-        this.dialog.worker.postMessage({ data, ctx }, transfer);
-
-        return data;
-    }
-
-    send(data?: Data<R, M>, done = false) {
-        return this.postMessage(data, done);
-    }
-
-    /**
-     * Does not automatically close, assumes consumer will close
-     *
-     * ```ts
-     * dialog.request('x').fetch((c) => {
-     *   c.response('x').listen(() => { ... }); // listens to "x", will be closed by upper level fetch
-     *   c.request('x').fetcH(y, (c) => { ... }); // closes
-     * }) // closes
-     *
-     * const un = dialog.context('x').listen((e) => { ... }); // listens to 'x'
-     * un(); // closes
-     *
-     * const un = dialog.context('x').listen((e) => { ... }); // listens to 'x'
-     * un(); // closes
-     * ```
-     */
-    listen(callback: Listener<R, M>, done = false): () => void {
-        checkClosed(this, 'listen');
-
-        const controller = new AbortController();
-
-        this.dialog.worker.addEventListener(
-            'message',
-            async (event: Event<R, M>) => {
-                try {
-                    const {
-                        data: { ctx, data },
-                    } = event;
-
-                    if (
-                        !ctx ||
-                        (this.id !== ALL && this.id !== ctx.id) ||
-                        this.message !== ctx.message ||
-                        (done && !ctx.done)
-                    )
-                        return; // unknown message from devtools etc., or different context
-
-                    /* v8 ignore next */
-                    if (this.dialog.debug) console.log('Listener event', this.info, event, this);
-
-                    await callback(data, this, event); // Requests can come here, but they're typed in responders
-                } catch (e) {
-                    /* v8 ignore next */
-                    if (this.dialog.debug) console.error(`Error in listener ${this.info}`, this, { event, e });
-                    //TODO Respond with error?
-                }
-            },
-            { signal: controller.signal },
-        );
-
-        const unsub = () => {
-            /* v8 ignore next */
-            if (this.dialog.debug >= 2) console.log('Stop listening', this.info, this);
-            controller.abort();
-            this.unsub.delete(unsub);
-        };
-
-        this.unsub.add(unsub);
-
-        return unsub;
-    }
-}
-
-class RequestContext<R, M extends keyof R> extends Context<R, M> {
-    type = 'request';
-
-    withMessage<M2 extends keyof R>(message: M2, id?: string): RequestContext<R, M2> {
-        return new RequestContext<R, M2>(this.dialog, message, id, this);
-    }
-
-    send(data?: MethodArg<R, M>, done = false): MethodArg<R, M> {
-        return super.send(data, done) as any;
-    }
-
-    listen(callback: Listener<R, M, MethodReturn<R, M>, RequestContext<R, M>>, done = false): () => void {
-        return super.listen(callback, done);
-    }
-
-    /**
-     * Returns response
-     * If you need to work with ctx, use callback
-     * Closed automatically on response
-     *
-     * dialog.fetch('x', (c) => {
-     *   c.listen(() => { ... }); // will be closed by upper level fetch
-     *   c.fetcH(y, (c) => { ... }); // closes c
-     *   c.context().fetcH(y, (c) => { ... }); // closes sub, not closes c, will be closed by upper level fetch
-     * })
-     */
-    async fetch(
-        data?: MethodArg<R, M>,
-        callback?: (context: RequestContext<R, M>) => void,
-    ): Promise<MethodReturn<R, M>> {
-        checkClosed(this, 'fetch');
-
-        const res = await Promise.all([
-            callback?.(this),
-            this.expect(), // will be closed in expect -> listener -> unsub
-            this.send(data, true),
-        ]);
-
-        /* v8 ignore next */
-        if (this.dialog.debug >= 2) console.log('Fetch', this.info, this);
-
-        this.close('fetch');
-
-        return res[1];
-    }
-
-    protected async expect() {
-        checkClosed(this, 'expect');
-
-        //FIXME Manual promise type
-        return new Promise<MethodReturn<R, M>>((resolve, reject) => {
-            const responseListener = this.listen(async (data) => {
-                try {
-                    if ((data as any) instanceof Error) throw data;
-                    responseListener();
-                    /* v8 ignore next */
-                    if (this.dialog.debug >= 3) console.log('Expect', this.info, data, this);
-                    resolve(data as any);
-                } catch (e) {
-                    reject(e);
-                }
-            }, true);
-        });
-    }
-}
-
-class ResponseContext<R, M extends keyof R> extends Context<R, M> {
-    type = 'response';
-
-    withMessage<M2 extends keyof R>(message: M2, id?: string): ResponseContext<R, M2> {
-        return new ResponseContext<R, M2>(this.dialog, message, id, this);
-    }
-
-    listen(callback: Listener<R, M, MethodArg<R, M>, ResponseContext<R, M>>, done = false): () => void {
-        return super.listen(callback, done);
-    }
-
-    send(data?: MethodReturn<R, M>, done = false): MethodReturn<R, M> {
-        return super.send(data, done) as any;
-    }
-}