@kirill.konshin/core 0.0.1

package/src/cache.ts

@@ -0,0 +1,245 @@
+import ManyKeysMap from 'many-keys-map';
+
+export type MaybePromise<T> = T | Promise<T>;
+
+export const shallowCompare = (prev: any, next: any): boolean =>
+    Array.from(new Set([...Object.keys(prev), ...Object.keys(next)])).every((key) => prev[key] === next[key]);
+
+export const equal = (prev: any, next: any): boolean => prev === next;
+
+const UNUSED = Symbol('UNUSED');
+export const ANY: unique symbol = Symbol('*');
+
+export function createTracker<Dep = any>(whenDifferent: (next: Dep, prev?: Dep) => any, shallow = false) {
+    let lastDependency: Dep = UNUSED as any;
+
+    const comparator = shallow ? shallowCompare : equal;
+
+    return function tracker(dependency: Dep): Dep | false {
+        // console.log('Tracker', lastDependency, dependency);
+
+        if (lastDependency !== UNUSED && comparator(lastDependency, dependency)) {
+            // console.log('RETAINED cache', { lastDependency, dependency });
+            return false;
+        }
+
+        // console.log('INVALIDATED cache', {lastDependency, dependency});
+
+        const res = whenDifferent(dependency, lastDependency === UNUSED ? undefined : lastDependency) || true;
+
+        lastDependency = dependency;
+
+        return res;
+    };
+}
+
+/**
+ * https://github.com/futpib/deep-weak-map
+ * https://github.com/fregante/many-keys-map
+ * https://github.com/fregante/many-keys-weakmap
+ * https://github.com/sindresorhus/memoize?tab=readme-ov-file#example-multiple-non-serializable-arguments
+ *
+ * ```ts
+ * const memoized = memo(
+ *   (file, options, ...args) => { ... },
+ *   {
+ *     key: (file, options, ...args) => [file, JSON.stringify(options), ...args],
+ *     invalidate: (bitmap) => !bitmap.width,
+ *     dispose: (bitmap) => bitmap.close(),
+ *   }
+ * );
+ * ```
+ */
+export function memo<Key extends any[], Val, SerializedKey extends any[] = Key>(
+    fn: (...args: Key) => MaybePromise<Val>,
+    {
+        key = (...k: Key) => k as never as SerializedKey,
+        invalidate,
+        dispose,
+    }: {
+        key?: (...key: Key) => SerializedKey;
+        invalidate?: (prev: Val, ...key: SerializedKey) => boolean;
+        dispose?: (prev: Val, ...key: SerializedKey) => void;
+    } = {},
+): {
+    (...args: Key): Promise<{
+        value?: Val;
+        hit: boolean;
+    }>;
+    clear: (...condition: Key | any[]) => void;
+    size: () => number;
+} {
+    const map = new ManyKeysMap<SerializedKey, Val>();
+
+    //TODO Extend ManyKeysMap
+    const clear = (...condition: Key | any[]) => {
+        if (!condition?.length) {
+            map.forEach((value, serializedKey) => {
+                dispose?.(value, ...serializedKey);
+            });
+            map.clear();
+            return;
+        }
+
+        const keyToClear = key(...(condition as any));
+
+        map.forEach((value, serializedKey) => {
+            if (!serializedKey.every((kk, i) => keyToClear[i] === ANY || kk === keyToClear[i])) return;
+            dispose?.(value, ...serializedKey);
+            map.delete(serializedKey);
+        });
+    };
+
+    const size = () => map.size;
+
+    async function memoized(...args: Key) {
+        const k = key(...args);
+
+        const has = map.has(k);
+        const old = map.get(k);
+
+        if (has && !invalidate?.(old as never as Val, ...k)) {
+            return { value: map.get(k), hit: true };
+        }
+
+        const value = await fn(...args);
+
+        map.set(k, value);
+
+        return { hit: false, value };
+    }
+
+    memoized.clear = clear;
+    memoized.size = size;
+
+    //TODO return mimic-function(memorized, fn);
+
+    return memoized;
+}
+
+/**
+ * Allows to memoize values by key and invalidate them based on the previous value.
+ *
+ * This makes possible to implement various one-off and subsequent transformations.
+ *
+ * 1. `write`: Transform value BEFORE writing to cache, called only once if cache IS NOT present or IS NOT valid
+ * 2. `read`: Transform value AFTER it's read from cache, always called if cache IS valid, keep in mind this transform is applied on top of BEFORE
+ *
+ * Both should return same type or null.
+ *
+ * If `newValue` is null, old is returned, and no cache is set.
+ *
+ * ```ts
+ * class InputCache extends TypedCache<string, ImageBitmap> {
+ *     dispose(bitmap: ImageBitmap, key: string) {
+ *         bitmap.close();
+ *     }
+ * }
+ *
+ * const cache = new InputCache('input');
+ *
+ * // Cache provided OffscreenCanvas by name and create context once per canvas
+ *
+ * class CanvasCache extends TypedCache<string, OffscreenCanvas> {
+ *     protected write(key: string, canvas: OffscreenCanvas): OffscreenCanvas {
+ *         const canvas = newValue.getContext('2d');
+ *         canvas.ctx = canvas;
+ *         return canvas;
+ *     }
+ * }
+ *
+ * // Transfer control to offscreen canvas and track removal of original
+ * // When called again, always return null, because canvas is handed to worker, and never returned to main
+ *
+ * class CanvasCache extends TypedCache<HTMLCanvasElement, OffscreenCanvas> {
+ *
+ *     protected write(canvas: HTMLCanvasElement): OffscreenCanvas {
+ *         canvas.addEventListener(
+ *             'remove',
+ *             function listener() {
+ *                 console.log('Removing canvas from cache', key);
+ *                 this.delete(canvas);
+ *                 key.removeEventListener('remove', listener);
+ *             },
+ *         );
+ *         return canvas.transferControlToOffscreen();
+ *     }
+ *
+ *     protected read() {
+ *         return null;
+ *     }
+ * }
+ *
+ * // Create bitmap from file and check if was used, return null if used
+ * // Since bitmaps are also cached in worker, used bitmaps are not sent
+ *
+ * class BitmapCache extends TypedCache<File, ImageBitmap, File> {
+ *     protected async write(file: File): Promise<ImageBitmap> {
+ *         return await createImageBitmap(file);
+ *     }
+ *
+ *     protected read(bitmap: ImageBitmap): Promise<ImageBitmap> | ImageBitmap {
+ *         if (!bitmap.width) return null;
+ *         return bitmap;
+ *     }
+ * }
+ *
+ * ```
+ */
+export abstract class TransformerMap<Key, Val = Key> extends Map<Key, Val> {
+    constructor(protected readonly name: string) {
+        // console.warn('CREATE cache', name);
+        super();
+    }
+
+    protected write(key: Key, newValue?: Val, oldValue?: Val): MaybePromise<Val> {
+        return newValue as Val;
+    }
+
+    protected read(oldValue: Val, key: Key): MaybePromise<Val> {
+        return oldValue;
+    }
+
+    delete(key: Key): boolean {
+        const val = this.get(key);
+        const has = typeof val !== 'undefined';
+        if (has) this.dispose(val, key);
+        super.delete(key);
+        return has;
+    }
+
+    /**
+     * Do something with the value and key before removing it from cache
+     * For example, close a file or a bitmap
+     */
+    protected dispose(value: Val, key: Key): void {}
+
+    clear(): void {
+        console.log('CLEAR cache', this.name);
+        this.forEach(this.dispose);
+        super.clear();
+    }
+
+    set(key: Key, value: Val): this {
+        throw new Error('Use memo() method instead');
+    }
+
+    async memo(key: Key, newValue?: Val): Promise<Val> {
+        const oldValue = this.get(key);
+
+        if (!!oldValue && (!newValue || newValue === oldValue)) {
+            // console.log('FROM cache', this.name, key, 'old value', oldValue);
+            return this.read?.(oldValue, key);
+        }
+
+        if (this.has(key)) this.delete(key);
+
+        const value = await this.write(key, newValue, oldValue);
+
+        super.set(key, value);
+
+        // console.log('INVALIDATED KEY cache', this.name, key, 'has', has, 'invalidate', invalidate, 'new value', value);
+
+        return value;
+    }
+}

package/src/errors.ts

@@ -0,0 +1,17 @@
+// @see https://www.youtube.com/watch?v=AdmGHwvgaVs
+export function catchErrors<T, E extends Error = Error>(
+    promise: Promise<T>,
+    errors?: E[],
+): Promise<any[] | (T | undefined)[]> {
+    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/files.ts

@@ -0,0 +1,29 @@
+export const downloadFile = async (file: File): Promise<void> => {
+    //FIXME https://github.com/eligrey/FileSaver.js/issues/471
+    const { saveAs } = require('file-saver');
+
+    //FIXME https://github.com/eligrey/FileSaver.js/issues/731
+    return saveAs(file, file.name);
+};
+
+export const createFile = async (text: any, filename = 'file.json', type = 'application/json'): Promise<File> => {
+    return new File([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/index.ts

@@ -0,0 +1,9 @@
+export * from './cache';
+export * from './errors';
+export * from './files';
+export * from './ls';
+export * from './measure';
+export * from './mutex';
+export * from './worker';
+export * from './workerUtils';
+export * from './wrpc';

package/src/ls.ts

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

package/src/measure.ts

@@ -0,0 +1,109 @@
+import { bold, magenta, cyan, yellow, red, green } from 'colors/safe';
+
+export const colored: {
+    important: typeof bold;
+    subject: typeof magenta;
+    arg: typeof cyan;
+    sup: typeof yellow;
+    err: typeof red;
+    ok: typeof green;
+} = {
+    important: bold,
+    subject: magenta,
+    arg: cyan,
+    sup: yellow,
+    err: red,
+    ok: green,
+};
+
+const noColor = (str) => str;
+
+export const uncolored: {
+    important: (str: any) => any;
+    subject: (str: any) => any;
+    arg: (str: any) => any;
+    sup: (str: any) => any;
+    err: (str: any) => any;
+    ok: (str: any) => any;
+} = {
+    important: noColor,
+    subject: noColor,
+    arg: noColor,
+    sup: noColor,
+    err: noColor,
+    ok: noColor,
+};
+
+export function createMeasurer({
+    colors = true,
+    prepend = 'LOG',
+    padding = 10,
+}: {
+    colors?: boolean;
+    prepend?: string;
+    padding?: number;
+}): {
+    measure: (
+        what: string,
+        step: string,
+        supplemental?: string,
+        ...args: any[]
+    ) => {
+        done: (result?: string, ...args2: any[]) => void;
+        fail: (result?: string, ...args2: any[]) => void;
+        log: (...args2: any[]) => void;
+    };
+    important: (str: any) => any;
+    subject: (str: any) => any;
+    arg: (str: any) => any;
+    sup: (str: any) => any;
+    ok: (str: any) => any;
+    err: (str: any) => any;
+} {
+    const { important, subject, arg, sup, ok, err } = colors ? colored : uncolored;
+
+    function measure(
+        what: string,
+        step: string,
+        supplemental: string = '',
+        ...args: any[]
+    ): {
+        done: (result?: string, ...args2: any[]) => void;
+        fail: (result?: string, ...args2: any[]) => void;
+        log: (...args2: any[]) => void;
+    } {
+        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: any[]): void => {
+            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: any[]): void => done(result, ...args2);
+
+        const log = (...args2: any[]): void => {
+            console.log(...prefix, ...args2);
+        };
+
+        return { done, fail, log };
+    }
+
+    return { measure, important, subject, arg, sup, ok, err };
+}

package/src/mutex.ts

@@ -0,0 +1,22 @@
+//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/worker.test.ts

@@ -0,0 +1,197 @@
+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/);
+    });
+});