@kirill.konshin/utils 0.0.19 → 0.0.20

package/src/core/README.md

@@ -1,91 +0,0 @@
-# WRPC
-
-TODO
-
-- [ ] Add to readme https://stackoverflow.com/questions/77727664/how-to-get-returned-value-from-async-generator-when-using-for-await
-- [ ] Value passed to next are ignored https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncGenerator/next#sending_values_to_the_generator
-
-```mermaid
-sequenceDiagram
-    box Main
-    participant Code
-    participant Caller
-    end
-    box Worker
-    participant Worker
-    participant Resolver
-    end
-
-    %% autonumber
-
-    Code->>Caller: caller.generator(payload)
-
-    Caller-->>Code: iterator & promise
-
-    Code->>Code: Start main CONSUMER loop
-
-    Code->>Caller: iterator[Symbol]()
-
-    Caller->>Caller: Start replica GENERATOR loop
-
-    Code->>Caller: iterator.next()
-
-    Caller->>Worker: postMessage(payload)
-
-    Worker->>Resolver: resolver(payload)
-
-    Resolver-->>Worker: iterator
-
-    Worker->>Worker: Start replica CONSUMER loop
-
-    Worker->>Resolver: iterator[Symbol]()
-
-    Resolver->>Resolver: Start GENERATOR loop
-
-    rect rgb(232, 244, 248)
-
-        loop Synchronized iteration
-            Worker->>+Resolver: iterator.next(payload)
-
-            Resolver-->>-Worker: yield value
-
-            Worker-->>Caller: postMessage(value, done=false)
-
-            Note over Worker: Wait for ACK or ABORT
-
-            Caller-->>Code: yield value
-
-            Code->>Caller: iterator.next(nextPayload)
-
-            Caller->>Worker: postMessage(ack, nextPayload)
-        end
-
-    end
-
-    break Break or AbortSignal (maybe)
-        Code-->>Code: Loop exits
-        Code->>Caller: signal.abort()
-
-        Caller-->>Caller: Loop exits
-
-        Caller->>Worker: postMessage(abort)
-
-        Worker-->>Worker: Loop exits via Break
-
-        Resolver-->>Resolver: Loop exits
-    end
-
-    opt Occurs on Error
-        Resolver-->>Worker: throw Error
-
-        Worker-->>Caller: postMessage(error, done=true)
-
-        Caller-->>Code: throw Error
-    end
-
-    Resolver-->>Worker: return value
-
-    Worker-->>Caller: postMessage(value, done=true)
-
-    Caller-->>Code: return value
-```

package/src/core/cache.test.ts

@@ -1,121 +0,0 @@
-import { expect, describe, test, vi } from 'vitest';
-import { ANY, MaybePromise, memo, TransformerMap } from './cache';
-
-describe('memo', async () => {
-    test('simple', async () => {
-        const random = vi.fn(() => Math.random());
-        const memoized = memo(random);
-
-        const first = await memoized();
-        const second = await memoized();
-
-        expect(first.hit).toBeFalsy();
-        expect(second.hit).toBeTruthy();
-        expect(first.value).toBe(second.value);
-        expect(memoized.size()).toBe(1);
-
-        memoized.clear();
-        expect(memoized.size()).toBe(0);
-
-        const third = await memoized();
-        expect(third.hit).toBeFalsy();
-    });
-
-    test('with key', async () => {
-        const random = vi.fn((arg) => arg + Math.random().toString());
-        const memoized = memo(random);
-
-        const first = await memoized(1);
-        const second = await memoized(2);
-
-        expect(first.hit).toBeFalsy();
-        expect(second.hit).toBeFalsy();
-        expect(first.value).not.toBe(second.value);
-        expect(memoized.size()).toBe(2);
-
-        const first2 = await memoized(1);
-        const second2 = await memoized(2);
-
-        expect(first2.hit).toBeTruthy();
-        expect(first.value).toBe(first2.value);
-        expect(second2.hit).toBeTruthy();
-        expect(second.value).toBe(second2.value);
-
-        memoized.clear(1);
-        expect(memoized.size()).toBe(1);
-        memoized.clear(ANY);
-        expect(memoized.size()).toBe(0);
-    });
-});
-
-describe('TransformerMap', async () => {
-    test('simple', async () => {
-        const dispose = vi.fn();
-
-        class Cache extends TransformerMap<number, any> {
-            write(key, value, oldValue) {
-                value.cached = true;
-                value.read = 0;
-                return value;
-            }
-            read(value, key) {
-                value.read++;
-                return value;
-            }
-            dispose(value, key) {
-                dispose(value, key);
-            }
-        }
-
-        const cache = new Cache('test');
-
-        const obj = { a: 1 };
-
-        const x1 = await cache.memo(1, obj);
-        expect(x1).toStrictEqual({ a: 1, cached: true, read: 0 });
-
-        const x2 = await cache.memo(1, obj);
-        expect(x2).toStrictEqual({ a: 1, cached: true, read: 1 });
-
-        const x3 = await cache.memo(1, { a: 2 });
-        expect(x3).toStrictEqual({ a: 2, cached: true, read: 0 });
-        expect(cache.size).toEqual(1);
-        expect(dispose).toBeCalledTimes(1);
-        expect(dispose).toBeCalledWith({ a: 1, cached: true, read: 1 }, 1);
-
-        const x4 = await cache.memo(2, { a: 20 });
-
-        expect(x4).toStrictEqual({ a: 20, cached: true, read: 0 });
-        expect(cache.size).toEqual(2);
-        expect(dispose).toBeCalledTimes(1);
-    });
-
-    test('key transform', async () => {
-        const dispose = vi.fn();
-
-        class Cache extends TransformerMap<number, any> {
-            write(key, value, oldValue) {
-                return { key, read: 0 };
-            }
-            read(value, key) {
-                value.read++;
-                return value;
-            }
-            dispose(value, key) {
-                dispose(value, key);
-            }
-        }
-
-        const cache = new Cache('test');
-
-        const x1 = await cache.memo(1);
-        expect(x1).toStrictEqual({ key: 1, read: 0 });
-
-        const x2 = await cache.memo(1);
-        expect(x2).toStrictEqual({ key: 1, read: 1 });
-
-        cache.clear();
-        expect(dispose).toBeCalledTimes(1);
-        expect(dispose).toBeCalledWith({ key: 1, read: 1 }, 1);
-    });
-});

package/src/core/cache.ts

@@ -1,246 +0,0 @@
-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 {
- *         let l;
- *         canvas.addEventListener(
- *             'remove',
- *             (l = () => {
- *                 console.log('Removing canvas from cache', key);
- *                 this.delete(canvas);
- *                 key.removeEventListener('remove', l);
- *             }),
- *         );
- *         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/core/errors.ts

@@ -1,17 +0,0 @@
-// @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/core/files.ts

@@ -1,29 +0,0 @@
-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/core/ls.ts

@@ -1,15 +0,0 @@
-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/core/measure.ts

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