@kirill.konshin/core 0.0.2 → 0.0.4

package/dist/cache.js

@@ -1,106 +1,184 @@
 import ManyKeysMap from "many-keys-map";
-const shallowCompare = (prev, next) => Array.from(/* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)])).every((key) => prev[key] === next[key]);
-const equal = (prev, next) => prev === next;
-const UNUSED = Symbol("UNUSED");
-const ANY = Symbol("*");
+//#region src/cache.ts
+var shallowCompare = (prev, next) => Array.from(/* @__PURE__ */ new Set([...Object.keys(prev), ...Object.keys(next)])).every((key) => prev[key] === next[key]);
+var equal = (prev, next) => prev === next;
+var UNUSED = Symbol("UNUSED");
+var ANY = Symbol("*");
 function createTracker(whenDifferent, shallow = false) {
-  let lastDependency = UNUSED;
-  const comparator = shallow ? shallowCompare : equal;
-  return function tracker(dependency) {
-    if (lastDependency !== UNUSED && comparator(lastDependency, dependency)) {
-      return false;
-    }
-    const res = whenDifferent(dependency, lastDependency === UNUSED ? void 0 : lastDependency) || true;
-    lastDependency = dependency;
-    return res;
-  };
+	let lastDependency = UNUSED;
+	const comparator = shallow ? shallowCompare : equal;
+	return function tracker(dependency) {
+		if (lastDependency !== UNUSED && comparator(lastDependency, dependency)) return false;
+		const res = whenDifferent(dependency, lastDependency === UNUSED ? void 0 : lastDependency) || true;
+		lastDependency = dependency;
+		return res;
+	};
 }
-function memo(fn, {
-  key = (...k) => k,
-  invalidate,
-  dispose
-} = {}) {
-  const map = new ManyKeysMap();
-  const clear = (...condition) => {
-    if (!condition?.length) {
-      map.forEach((value, serializedKey) => {
-        dispose?.(value, ...serializedKey);
-      });
-      map.clear();
-      return;
-    }
-    const keyToClear = key(...condition);
-    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) {
-    const k = key(...args);
-    const has = map.has(k);
-    const old = map.get(k);
-    if (has && !invalidate?.(old, ...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;
-  return memoized;
+/**
+* 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(),
+*   }
+* );
+* ```
+*/
+function memo(fn, { key = (...k) => k, invalidate, dispose } = {}) {
+	const map = new ManyKeysMap();
+	const clear = (...condition) => {
+		if (!condition?.length) {
+			map.forEach((value, serializedKey) => {
+				dispose?.(value, ...serializedKey);
+			});
+			map.clear();
+			return;
+		}
+		const keyToClear = key(...condition);
+		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) {
+		const k = key(...args);
+		const has = map.has(k);
+		const old = map.get(k);
+		if (has && !invalidate?.(old, ...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;
+	return memoized;
 }
-class TransformerMap extends Map {
-  constructor(name) {
-    super();
-    this.name = name;
-  }
-  write(key, newValue, oldValue) {
-    return newValue;
-  }
-  read(oldValue, key) {
-    return oldValue;
-  }
-  delete(key) {
-    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
-   */
-  dispose(value, key) {
-  }
-  clear() {
-    console.log("CLEAR cache", this.name);
-    this.forEach(this.dispose);
-    super.clear();
-  }
-  set(key, value) {
-    throw new Error("Use memo() method instead");
-  }
-  async memo(key, newValue) {
-    const oldValue = this.get(key);
-    if (!!oldValue && (!newValue || newValue === 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);
-    return value;
-  }
-}
-export {
-  ANY,
-  TransformerMap,
-  createTracker,
-  equal,
-  memo,
-  shallowCompare
+/**
+* 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;
+*     }
+* }
+*
+* ```
+*/
+var TransformerMap = class extends Map {
+	name;
+	constructor(name) {
+		super();
+		this.name = name;
+	}
+	write(key, newValue, oldValue) {
+		return newValue;
+	}
+	read(oldValue, key) {
+		return oldValue;
+	}
+	delete(key) {
+		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
+	*/
+	dispose(value, key) {}
+	clear() {
+		console.log("CLEAR cache", this.name);
+		this.forEach(this.dispose);
+		super.clear();
+	}
+	set(key, value) {
+		throw new Error("Use memo() method instead");
+	}
+	async memo(key, newValue) {
+		const oldValue = this.get(key);
+		if (!!oldValue && (!newValue || newValue === 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);
+		return value;
+	}
 };
-//# sourceMappingURL=cache.js.map
+//#endregion
+export { ANY, TransformerMap, createTracker, equal, memo, shallowCompare };
+
+//# sourceMappingURL=cache.js.map

package/dist/cache.js.map

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

package/dist/errors.js

@@ -1,15 +1,12 @@
+//#region src/errors.ts
 function catchErrors(promise, errors) {
-  return promise.then((data) => [void 0, data]).catch((error) => {
-    if (!errors?.length) {
-      return [error];
-    }
-    if (errors.some((e) => e instanceof error)) {
-      return [error];
-    }
-    throw error;
-  });
+	return promise.then((data) => [void 0, data]).catch((error) => {
+		if (!errors?.length) return [error];
+		if (errors.some((e) => e instanceof error)) return [error];
+		throw error;
+	});
 }
-export {
-  catchErrors
-};
-//# sourceMappingURL=errors.js.map
+//#endregion
+export { catchErrors };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sources":["../src/errors.ts"],"sourcesContent":["// @see https://www.youtube.com/watch?v=AdmGHwvgaVs\nexport function catchErrors<T, E extends Error = Error>(\n    promise: Promise<T>,\n    errors?: E[],\n): Promise<any[] | (T | undefined)[]> {\n    return promise\n        .then((data) => [undefined, data])\n        .catch((error) => {\n            if (!errors?.length) {\n                return [error];\n            }\n            if (errors.some((e) => e instanceof error)) {\n                return [error];\n            }\n            throw error;\n        });\n}\n"],"names":[],"mappings":"AACO,SAAS,YACZ,SACA,QACkC;AAClC,SAAO,QACF,KAAK,CAAC,SAAS,CAAC,QAAW,IAAI,CAAC,EAChC,MAAM,CAAC,UAAU;AACd,QAAI,CAAC,QAAQ,QAAQ;AACjB,aAAO,CAAC,KAAK;AAAA,IACjB;AACA,QAAI,OAAO,KAAK,CAAC,MAAM,aAAa,KAAK,GAAG;AACxC,aAAO,CAAC,KAAK;AAAA,IACjB;AACA,UAAM;AAAA,EACV,CAAC;AACT;"}
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["// @see https://www.youtube.com/watch?v=AdmGHwvgaVs\nexport function catchErrors<T, E extends Error = Error>(\n    promise: Promise<T>,\n    errors?: E[],\n): Promise<any[] | (T | undefined)[]> {\n    return promise\n        .then((data) => [undefined, data])\n        .catch((error) => {\n            if (!errors?.length) {\n                return [error];\n            }\n            if (errors.some((e) => e instanceof error)) {\n                return [error];\n            }\n            throw error;\n        });\n}\n"],"mappings":";AACA,SAAgB,YACZ,SACA,QACkC;CAClC,OAAO,QACF,MAAM,SAAS,CAAC,KAAA,GAAW,IAAI,CAAC,CAAC,CACjC,OAAO,UAAU;EACd,IAAI,CAAC,QAAQ,QACT,OAAO,CAAC,KAAK;EAEjB,IAAI,OAAO,MAAM,MAAM,aAAa,KAAK,GACrC,OAAO,CAAC,KAAK;EAEjB,MAAM;CACV,CAAC;AACT"}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export * from './cache';
-export * from './errors';
-export * from './mutex';
+export * from './cache.js';
+export * from './errors.js';
+export * from './mutex.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,14 +1,4 @@
 import { ANY, TransformerMap, createTracker, equal, memo, shallowCompare } from "./cache.js";
 import { catchErrors } from "./errors.js";
 import { Mutex } from "./mutex.js";
-export {
-  ANY,
-  Mutex,
-  TransformerMap,
-  catchErrors,
-  createTracker,
-  equal,
-  memo,
-  shallowCompare
-};
-//# sourceMappingURL=index.js.map
+export { ANY, Mutex, TransformerMap, catchErrors, createTracker, equal, memo, shallowCompare };

package/dist/mutex.d.ts

@@ -1,6 +1,6 @@
 export declare class Mutex {
     private promise;
-    exec(fn: (...args: any) => any): ReturnType<typeof fn>;
-    wrap(fn: (...args: any) => any): ReturnType<typeof fn>;
+    exec<T extends (...args: any) => any>(fn: T): Promise<ReturnType<T>>;
+    wrap<T extends (...args: any) => any>(fn: T): () => Promise<ReturnType<T>>;
 }
 //# sourceMappingURL=mutex.d.ts.map

package/dist/mutex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mutex.d.ts","sourceRoot":"","sources":["../src/mutex.ts"],"names":[],"mappings":"AAEA,qBAAa,KAAK;IACd,OAAO,CAAC,OAAO,CAAqB;IAE7B,IAAI,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC;IAatD,IAAI,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,GAAG,UAAU,CAAC,OAAO,EAAE,CAAC;CAGhE"}
+{"version":3,"file":"mutex.d.ts","sourceRoot":"","sources":["../src/mutex.ts"],"names":[],"mappings":"AAEA,qBAAa,KAAK;IACd,OAAO,CAAC,OAAO,CAAqB;IAE7B,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAcpE,IAAI,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,EAAE,EAAE,CAAC,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;CAGpF"}

package/dist/mutex.js

@@ -1,21 +1,22 @@
-class Mutex {
-  promise = Promise.resolve();
-  exec(fn) {
-    return new Promise((resolve, reject) => {
-      this.promise = this.promise.then(async () => {
-        try {
-          resolve(await fn());
-        } catch (e) {
-          reject(e);
-        }
-      });
-    });
-  }
-  wrap(fn) {
-    return (...args) => this.exec(() => fn(...args));
-  }
-}
-export {
-  Mutex
+//#region src/mutex.ts
+var Mutex = class {
+	promise = Promise.resolve();
+	exec(fn) {
+		return new Promise((resolve, reject) => {
+			this.promise = this.promise.then(async () => {
+				try {
+					resolve(await fn());
+				} catch (e) {
+					reject(e);
+				}
+			});
+		});
+	}
+	wrap(fn) {
+		return (...args) => this.exec(() => fn(...args));
+	}
 };
-//# sourceMappingURL=mutex.js.map
+//#endregion
+export { Mutex };
+
+//# sourceMappingURL=mutex.js.map

package/dist/mutex.js.map

@@ -1 +1 @@
-{"version":3,"file":"mutex.js","sources":["../src/mutex.ts"],"sourcesContent":["//TODO Implement queue with ranking & sorting\n//TODO https://github.com/sindresorhus/p-queue\nexport class Mutex {\n    private promise = Promise.resolve();\n\n    public exec(fn: (...args: any) => any): ReturnType<typeof fn> {\n        return new Promise((resolve, reject) => {\n            // wrap in always successful function\n            this.promise = this.promise.then(async () => {\n                try {\n                    resolve(await fn());\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        });\n    }\n\n    public wrap(fn: (...args: any) => any): ReturnType<typeof fn> {\n        return (...args: any) => this.exec(() => fn(...args));\n    }\n}\n"],"names":[],"mappings":"AAEO,MAAM,MAAM;AAAA,EACP,UAAU,QAAQ,QAAA;AAAA,EAEnB,KAAK,IAAkD;AAC1D,WAAO,IAAI,QAAQ,CAAC,SAAS,WAAW;AAEpC,WAAK,UAAU,KAAK,QAAQ,KAAK,YAAY;AACzC,YAAI;AACA,kBAAQ,MAAM,IAAI;AAAA,QACtB,SAAS,GAAG;AACR,iBAAO,CAAC;AAAA,QACZ;AAAA,MACJ,CAAC;AAAA,IACL,CAAC;AAAA,EACL;AAAA,EAEO,KAAK,IAAkD;AAC1D,WAAO,IAAI,SAAc,KAAK,KAAK,MAAM,GAAG,GAAG,IAAI,CAAC;AAAA,EACxD;AACJ;"}
+{"version":3,"file":"mutex.js","names":[],"sources":["../src/mutex.ts"],"sourcesContent":["//TODO Implement queue with ranking & sorting\n//TODO https://github.com/sindresorhus/p-queue\nexport class Mutex {\n    private promise = Promise.resolve();\n\n    public exec<T extends (...args: any) => any>(fn: T): Promise<ReturnType<T>> {\n        return new Promise((resolve, reject) => {\n            // wrap in always successful function\n            // eslint-disable-next-line promise/prefer-await-to-then\n            this.promise = this.promise.then(async () => {\n                try {\n                    resolve(await fn());\n                } catch (e) {\n                    reject(e);\n                }\n            });\n        });\n    }\n\n    public wrap<T extends (...args: any) => any>(fn: T): () => Promise<ReturnType<T>> {\n        return (...args: any) => this.exec(() => fn(...args));\n    }\n}\n"],"mappings":";AAEA,IAAa,QAAb,MAAmB;CACf,UAAkB,QAAQ,QAAQ;CAElC,KAA6C,IAA+B;EACxE,OAAO,IAAI,SAAS,SAAS,WAAW;GAGpC,KAAK,UAAU,KAAK,QAAQ,KAAK,YAAY;IACzC,IAAI;KACA,QAAQ,MAAM,GAAG,CAAC;IACtB,SAAS,GAAG;KACR,OAAO,CAAC;IACZ;GACJ,CAAC;EACL,CAAC;CACL;CAEA,KAA6C,IAAqC;EAC9E,QAAQ,GAAG,SAAc,KAAK,WAAW,GAAG,GAAG,IAAI,CAAC;CACxD;AACJ"}

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "@kirill.konshin/core",
   "description": "Utilities",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "scripts": {
     "----- BUILD -----": "",
     "clean": "rm -rf dist .tscache tsconfig.tsbuildinfo",
     "build": "vite build",
-    "build:index": "ctix build",
-    "build:check-types": "attw --pack .",
     "start": "yarn build --watch",
     "wait": "wait-on ./dist/index.js",
     "----- TEST -----": "",
@@ -40,5 +38,17 @@
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "peerDependenciesMeta": {}
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kirill-konshin/utils.git",
+    "directory": "packages/core"
+  },
+  "nx": {
+    "tags": [
+      "platform:universal"
+    ]
+  },
+  "files": [
+    "dist"
+  ]
 }

package/.ctirc

@@ -1,20 +0,0 @@
-{
-  "options": [
-    {
-      "mode": "create",
-      "project": "tsconfig.json",
-      "include": "src/**/*.{ts,tsx}",
-      "exclude": [
-        "**/*.stories.*",
-        "**/*.test.*",
-        "**/*.fixture.*"
-      ],
-      "startFrom": "src",
-      "backup": false,
-      "overwrite": true,
-      "generationStyle": "default-alias-named-star",
-      "output": "src",
-      "verbose": true
-    }
-  ]
-}

package/.turbo/turbo-build.log

@@ -1,22 +0,0 @@
-vite v7.0.6 building SSR bundle for production...
-- ctix 'create' mode start, ...
-✔ /home/runner/work/utils/utils/packages/core/tsconfig.json loading complete!
-✔ analysis export statements completed!
-- build "index.ts" file start
-- output file exists check, ...
-
-
-✔ ctix 'create' mode complete!
-transforming...
-✓ 4 modules transformed.
-rendering chunks...
-
-[vite:dts] Start generate declaration files...
-dist/index.js   0.32 kB │ map:  0.09 kB
-dist/errors.js  0.33 kB │ map:  0.90 kB
-dist/mutex.js   0.40 kB │ map:  1.18 kB
-dist/cache.js   2.92 kB │ map: 10.21 kB
-[vite:dts] Declaration files built in 1642ms.
-
-✓ built in 4.86s
-Updated package.json with exports

package/.turbo/turbo-test.log

@@ -1,37 +0,0 @@
-- ctix 'create' mode start, ...
-✔ /home/runner/work/utils/utils/packages/core/tsconfig.json loading complete!
-✔ analysis export statements completed!
-- build "index.ts" file start
-- output file exists check, ...
-
-
-✔ ctix 'create' mode complete!
-
- RUN  v3.2.4 /home/runner/work/utils/utils/packages/core
-      Coverage enabled with v8
-
-stdout | src/cache.test.ts > TransformerMap > key transform
-CLEAR cache test
-
- ✓ src/cache.test.ts (4 tests) 10ms
-
- Test Files  1 passed (1)
-      Tests  4 passed (4)
-   Start at  03:27:08
-   Duration  465ms (transform 54ms, setup 0ms, collect 47ms, tests 10ms, environment 0ms, prepare 83ms)
-
- % Coverage report from v8
------------------|---------|----------|---------|---------|---------------------
-File             | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s   
------------------|---------|----------|---------|---------|---------------------
-All files        |   42.85 |    84.84 |      55 |   42.85 |                     
- demo            |       0 |        0 |       0 |       0 |                     
-  worker-demo.ts |       0 |        0 |       0 |       0 | 1-73                
- src             |   59.09 |     87.5 |   57.89 |   59.09 |                     
-  cache.ts       |   81.25 |    89.65 |   56.25 |   81.25 | ...,200-201,224-225 
-  errors.ts      |       0 |      100 |     100 |       0 | 2-17                
-  index.ts       |       0 |        0 |       0 |       0 | 1-3                 
-  mutex.ts       |       0 |      100 |     100 |       0 | 3-22                
------------------|---------|----------|---------|---------|---------------------
-Updated package.json with exports
-Updated package.json with exports

package/CHANGELOG.md

@@ -1,8 +0,0 @@
-# @kirill.konshin/core
-
-## 0.0.2
-
-### Patch Changes
-
-- 63fdba8: Agent-assisted refactoring
-- 63fdba8: Divided core to browser/node/worker-specific packages, CTIX upgrade, etc.

package/demo/worker-demo.ts

@@ -1,73 +0,0 @@
-import { RespondersBase, WorkerDialog } from '../src';
-
-class Responders extends RespondersBase<Responders> {
-    encode = this.create(
-        'encode',
-        async (
-            { file, abort = false }: { file: File; abort: boolean }, // should have all possible combinations for strong typing
-            encodeContext,
-        ) => {
-            // send within same message
-            encodeContext.send({ progress: 0 }); // ✅ Valid
-            encodeContext.send({ junk: 'xxx' }); // ❌ Bad & should be red
-
-            // listen same message
-            encodeContext.listen(({ abort }) => {
-                if (abort) alert('Aborted'); // ✅ Valid
-            });
-
-            // send same message as received
-            encodeContext.send({ junk: 'xxx' }); // ❌ Bad & should be red
-            encodeContext.send({ progress: 0.5 }); //  ✅ Valid
-
-            // send or listen different message
-            encodeContext.withMessage('decode').listen(() => {}); // ✅ Valid
-            encodeContext.withMessage('decode').send({ file: null }); // ✅ Valid
-            encodeContext.withMessage('decode').send({ junk: 'xxx' }); // ❌ Bad & should be red
-            encodeContext.withMessage('junk'); // ❌ Bad & should be red
-
-            return { bitmap: await createImageBitmap(file), progress: 1.0 }; // should have all possible combinations for strong typing
-        },
-    );
-
-    // another responder for demo purposes
-    decode = this.create('decode', async ({ bitmap }) => {
-        return { file: new File([], 'test') };
-    });
-}
-
-export const workerDialog = new WorkerDialog(self, new Responders(), 'Worker');
-
-/////
-
-// import type { workerDialog } from './worker';
-
-const mainDialog = new WorkerDialog(self, {} as typeof workerDialog.responders, 'Main');
-
-mainDialog
-    .withMessage('encode')
-    .fetch(
-        {
-            file: new File([], 'test'), // ✅ Valid
-            junk: 'xxx', // ❌ Bad & should be red
-        },
-        (encodeContext) => {
-            // Listen same message, partial data update
-            encodeContext.listen((data) => {
-                console.log(data.progress); // ✅ Valid
-                console.log(data.junk); // ❌ Bad & should be red
-            });
-
-            // Listen or send other message
-            encodeContext.withMessage('decode').listen((data, decodeContext) => {});
-            encodeContext.withMessage('decode').send({ bitmap: null }); // ✅ Valid
-            encodeContext.withMessage('decode').send({ junk: 'xxx' }); // ❌❌❌ Bad & should be red, broken
-
-            // Send abort
-            encodeContext.send({ abort: true }); // ✅ Valid
-        },
-    )
-    .then((result) => {
-        console.log(result.bitmap); // ✅ Valid
-        console.log(result.junk); // ❌ Bad & should be red
-    });

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/src/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/cache.ts

@@ -1,245 +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 {
- *         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

@@ -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/index.ts

@@ -1,3 +0,0 @@
-export * from './cache';
-export * from './errors';
-export * from './mutex';

package/src/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/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../utils-private/tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "dist",
-    "declarationDir": "dist"
-  },
-  "include": ["src"],
-  "exclude": []
-}

package/turbo.json

@@ -1,10 +0,0 @@
-{
-  "$schema": "https://turbo.build/schema.json",
-  "extends": ["//"],
-  "tasks": {
-    "build": {
-      "dependsOn": ["^build"],
-      "outputs": ["src/**/*/index.ts", "package.json", "dist/**/*"]
-    }
-  }
-}

package/vite.config.ts

@@ -1,2 +0,0 @@
-import config from '../utils-private/vite.config';
-export default config;