@kirill.konshin/utils 0.0.7 → 0.0.9

package/vite.exports.ts

@@ -0,0 +1,121 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { globSync } from 'glob';
+import { execSync } from 'node:child_process';
+
+export const pkgPath = path.join(process.cwd(), 'package.json');
+
+export const distDir = './dist';
+
+//TODO Re-read in fixExports
+// import pkg from './package.json' assert { type: 'json' };
+// export { pkg };
+export const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+export const rootPkg = JSON.parse(fs.readFileSync(path.resolve('../../package.json'), 'utf-8'));
+
+export const formats = {
+    // cjs: ['require', 'js', 'd.ts'],
+    esm: ['import', 'mjs', 'd.ts'],
+};
+
+export const entryGlob = 'src/*/index.ts';
+export const excludeGlob = 'src/**/*.{stories,test}.{ts,tsx}';
+export const includeGlob = 'src/**/!(*.stories|*.test).{ts,tsx}';
+export const foldersGlob = 'src/*/';
+
+export const external = [
+    ...[...Object.keys(pkg.dependencies), ...Object.keys(pkg.devDependencies)].map(
+        (dep) => new RegExp(`^${dep}(/.*)?`),
+    ),
+    /node_modules/,
+    /^node:.*/,
+    /builder-util-runtime/,
+];
+
+export const entry = globSync(entryGlob);
+
+export async function fixExports() {
+    const modules = globSync(foldersGlob).map((file) => path.basename(file));
+
+    // Exports
+
+    pkg.exports = {};
+
+    // https://johnnyreilly.com/dual-publishing-esm-cjs-modules-with-tsup-and-are-the-types-wrong
+    // https://www.npmjs.com/package/@arethetypeswrong/cli
+    // FIXME https://github.com/andrewbranch/example-subpath-exports-ts-compat
+    for (const entry of modules) {
+        const key = `./${entry}`;
+
+        pkg.exports[key] = {};
+
+        for (const [format, ext, type] of Object.values(formats)) {
+            const fileName = `${distDir}/${entry}/index`;
+
+            pkg.exports[key][format] = {
+                [format]: `${fileName}.${ext}`,
+                types: `${fileName}.${type}`,
+            };
+        }
+    }
+
+    const core = pkg.exports['./core'];
+
+    pkg.exports['.'] = core;
+
+    // Main
+
+    pkg.type = 'module';
+    pkg.main = pkg.module = core.import.import;
+    pkg.types = core.import.types;
+
+    // Author & License
+
+    // TODO Move to root build + set private=true for demos + set react version
+    pkg.publishConfig = { access: 'public' };
+    pkg.author = 'Kirill Konshin <kirill@konshin.org> (https://konshin.org)';
+    pkg.license = 'MIT';
+
+    // Scripts
+
+    // pkg.scripts.clean = 'rm -rf dist .tscache tsconfig.tsbuildinfo';
+    // pkg.scripts.build = 'vite build';
+    // pkg.scripts.start = 'yarn build --watch';
+    pkg.scripts.wait = `wait-on ${core.import.import}`;
+
+    // Ensure peer deps are correct & meta is set
+
+    pkg.peerDependenciesMeta = {};
+
+    for (const [key, _] of Object.entries(pkg.peerDependencies)) {
+        const root = rootPkg.devDependencies[key]; // lifted to root
+        const srcPkg = root ? rootPkg : pkg;
+
+        if (!srcPkg.devDependencies[key]) throw new Error(`Key ${key} not found in dependencies`);
+
+        pkg.peerDependenciesMeta[key] = { optional: true };
+
+        const version = srcPkg.devDependencies[key].split('.');
+
+        pkg.peerDependencies[key] = version[0] === '^0' ? `${version[0]}.${version[1]}` : version[0];
+    }
+
+    // Write
+
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+
+    console.log('Updated package.json with exports');
+    // console.log(pkg);
+    // console.log(pkg.exports);
+}
+
+export async function generateIndex() {
+    execSync(`yarn build:index`, { stdio: 'inherit' }); // programmatic call
+    //FIXME https://github.com/imjuni/create-ts-index/issues/70
+    // import { TypeScritIndexWriter } from 'create-ts-index';
+    // const tsiw = new TypeScritIndexWriter();
+    // const options = TypeScritIndexWriter.getDefaultOption('./src');
+    // await tsiw.createEntrypoint(option);
+}

package/build/cache.d.ts

@@ -1,119 +0,0 @@
-export type MaybePromise<T> = T | Promise<T>;
-export declare const shallowCompare: (prev: any, next: any) => boolean;
-export declare const equal: (prev: any, next: any) => boolean;
-export declare function createTracker<Dep = any>(whenDifferent: (next: Dep, prev: Dep) => boolean, shallow?: boolean): (dependency: Dep) => boolean;
-/**
- * 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 declare function memo<Key extends any[], Val, SerializedKey extends any[] = Key>(fn: (...args: Key) => MaybePromise<Val>, { key, invalidate, dispose, }?: {
-    key?: (...key: Key) => SerializedKey;
-    invalidate?: (prev: Val, ...key: SerializedKey) => boolean;
-    dispose?: (prev: Val, ...key: SerializedKey) => void;
-}): {
-    (...args: Key): Promise<{
-        value: Val | undefined;
-        hit: boolean;
-    }>;
-    clear: () => void;
-    size: () => number;
-};
-/**
- * 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`: Before writing to cache, called only once if cache is present and valid
- * 2. `read`: After it's read from cache, always called if cache is valid
- * TODO Better names: once, folloing
- * TODO Better names: memoize, recover
- * TODO Better names: writeTransformer, readTransformer
- * TODO Better names: writeModifier, readModifier
- * TODO Better names: write, read
- *
- * 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 declare abstract class TransformerMap<Key, Val = Key> extends Map<Key, Val> {
-    protected readonly name: string;
-    constructor(name: string);
-    protected write(key: Key, newValue?: Val, oldValue?: Val): MaybePromise<Val>;
-    protected read(oldValue: Val, key: Key): MaybePromise<Val>;
-    delete(key: Key): boolean;
-    protected dispose(value: Val, key: Key): void;
-    clear(): void;
-    set(key: Key, value: Val): this;
-    memo(key: Key, newValue?: Val): Promise<Val>;
-}

package/build/cache.js

@@ -1,176 +0,0 @@
-import ManyKeysMap from 'many-keys-map';
-export const shallowCompare = (prev, next) => Array.from(new Set([...Object.keys(prev), ...Object.keys(next)])).every((key) => prev[key] === next[key]);
-export const equal = (prev, next) => prev === next;
-export function createTracker(whenDifferent, shallow = false) {
-    let lastDependency = null;
-    const comparator = shallow ? shallowCompare : equal;
-    return function tracker(dependency) {
-        if (!lastDependency || !dependency || comparator(lastDependency, dependency)) {
-            // console.log('RETAINED cache', this.name, 'last', this.lastObj, 'new', obj);
-            return false;
-        }
-        // console.log('INVALIDATED cache', this.name, 'last', this.lastObj, 'new', obj);
-        lastDependency = dependency;
-        return whenDifferent(dependency, lastDependency) || true;
-    };
-}
-/**
- * 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(fn, { key = (...k) => k, invalidate, dispose, } = {}) {
-    const map = new ManyKeysMap();
-    const clear = () => {
-        if (dispose) {
-            map.forEach((value, key) => dispose(value, ...key));
-        }
-        map.clear();
-    };
-    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 === null || invalidate === void 0 ? void 0 : 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;
-    //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`: Before writing to cache, called only once if cache is present and valid
- * 2. `read`: After it's read from cache, always called if cache is valid
- * TODO Better names: once, folloing
- * TODO Better names: memoize, recover
- * TODO Better names: writeTransformer, readTransformer
- * TODO Better names: writeModifier, readModifier
- * TODO Better names: write, read
- *
- * 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 class TransformerMap extends Map {
-    constructor(name) {
-        super();
-        this.name = name;
-    }
-    write(key, newValue, oldValue) {
-        return newValue;
-    }
-    read(oldValue, key) {
-        return oldValue;
-    }
-    delete(key) {
-        const has = this.has(key);
-        if (has)
-            this.dispose(this.get(key), key);
-        super.delete(key);
-        return has;
-    }
-    // do something with the value and key before removing it
-    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) {
-        var _a;
-        const oldValue = this.get(key);
-        if (!!oldValue && (!newValue || newValue === oldValue)) {
-            // console.log('FROM cache', this.name, key, 'old value', oldValue);
-            return (_a = this.read) === null || _a === void 0 ? void 0 : _a.call(this, 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/build/errors.d.ts

@@ -1 +0,0 @@
-export declare function catchErrors<T, E extends Error = Error>(promise: Promise<T>, errors?: E[]): Promise<any[] | (T | undefined)[]>;

package/build/errors.js

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

package/build/index.d.ts

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

package/build/index.js

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

package/build/measure.d.ts

@@ -1,34 +0,0 @@
-import { bold, magenta, cyan, yellow, red, green } from 'colors/safe';
-export declare const colored: {
-    important: typeof bold;
-    subject: typeof magenta;
-    arg: typeof cyan;
-    sup: typeof yellow;
-    err: typeof red;
-    ok: typeof green;
-};
-export declare 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;
-};
-export declare function createMeasurer({ colors, prepend, padding }: {
-    colors?: boolean | undefined;
-    prepend?: string | undefined;
-    padding?: number | undefined;
-}): {
-    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;
-};

package/build/measure.js

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

package/build/mutex.d.ts

@@ -1,5 +0,0 @@
-export declare class Mutex {
-    private promise;
-    exec(fn: (...args: any) => any): ReturnType<typeof fn>;
-    wrap(fn: (...args: any) => any): ReturnType<typeof fn>;
-}

package/build/mutex.js

@@ -1,23 +0,0 @@
-//TODO Implement queue with ranking & sorting
-//TODO https://github.com/sindresorhus/p-queue
-export class Mutex {
-    constructor() {
-        this.promise = Promise.resolve();
-    }
-    exec(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);
-                }
-            });
-        });
-    }
-    wrap(fn) {
-        return (...args) => this.exec(() => fn(...args));
-    }
-}

package/build/worker.d.ts

@@ -1,83 +0,0 @@
-export declare function isTransferable(obj: any): boolean;
-type WebWorker = Worker | (Window & typeof globalThis) | (WorkerGlobalScope & typeof globalThis);
-type MethodReturn<R, M extends keyof R> = R[M] extends (...args: any[]) => any ? Partial<Awaited<ReturnType<R[M]>>> : never;
-type MethodArg<R, M extends keyof R> = R[M] extends (arg: infer A, ...args: any[]) => any ? Partial<A> : never;
-export type Ctx<R, K extends keyof R> = {
-    id: string;
-    parentId?: string;
-    message: K;
-};
-type Data<R, M extends keyof R> = MethodReturn<R, M> | MethodArg<R, M> | Error;
-type Event<R, M extends keyof R> = MessageEvent<{
-    data: Data<R, M>;
-    ctx: Ctx<R, M>;
-}>;
-type Listener<R, M extends keyof R, D extends Data<R, M> = Data<R, M>, S extends Context<R, M> = Context<R, M>> = (data: D, self: S, event: Event<R, M>) => void | Promise<void>;
-export declare class WorkerDialog<R extends RespondersBase<any>> {
-    worker: WebWorker;
-    responders: R;
-    name: string;
-    readonly contexts: Set<Context<R, keyof R>>;
-    protected closed: boolean;
-    constructor(worker: WebWorker, responders: R, name: string);
-    close(): void;
-    withMessage<M extends keyof R>(message: M): RequestContext<R, M>;
-}
-export declare class RespondersBase<R> {
-    create<M extends keyof R, F extends (input: any, context: ResponseContext<R, M>) => any>(message: M, responder: F): F;
-}
-declare abstract class Context<R, M extends keyof R> {
-    protected readonly dialog: WorkerDialog<any>;
-    message: M;
-    id: string | undefined;
-    parent: Context<R, keyof R> | undefined | null;
-    protected readonly unsub: Set<() => void>;
-    protected closed: boolean;
-    constructor(dialog: WorkerDialog<any>, message: M, id: string | undefined, parent?: Context<R, keyof R> | undefined | null);
-    abstract withMessage<M2 extends keyof R>(message: M2, id?: string): Context<R, M2>;
-    close(reason?: string): void;
-    get info(): string;
-    protected postMessage(data?: Data<R, M>): Data<R, M> | undefined;
-    send(data?: Data<R, M>): Data<R, M> | undefined;
-    /**
-     * Does not automatically close, assumes consumer will close
-     *
-     * ```ts
-     * dialog.request('x').fetch((c) => {
-     *   c.response('x').listen(() => { ... }); // listens to "x", will be closed by upper level fetch
-     *   c.request('x').fetcH(y, (c) => { ... }); // closes
-     * }) // closes
-     *
-     * const un = dialog.context('x').listen((e) => { ... }); // listens to 'x'
-     * un(); // closes
-     *
-     * const un = dialog.context('x').listen((e) => { ... }); // listens to 'x'
-     * un(); // closes
-     * ```
-     */
-    listen(callback: Listener<R, M>): () => void;
-}
-declare class RequestContext<R, M extends keyof R> extends Context<R, M> {
-    withMessage<M2 extends keyof R>(message: M2, id?: string): RequestContext<R, M2>;
-    send(data?: MethodArg<R, M>): MethodArg<R, M>;
-    listen(callback: Listener<R, M, MethodReturn<R, M>, RequestContext<R, M>>): () => void;
-    /**
-     * Returns response
-     * If you need to work with ctx, use callback
-     * Closed automatically on response
-     *
-     * dialog.fetch('x', (c) => {
-     *   c.listen(() => { ... }); // will be closed by upper level fetch
-     *   c.fetcH(y, (c) => { ... }); // closes c
-     *   c.context().fetcH(y, (c) => { ... }); // closes sub, not closes c, will be closed by upper level fetch
-     * })
-     */
-    fetch(data?: MethodArg<R, M>, callback?: (context: RequestContext<R, M>) => void): Promise<MethodReturn<R, M>>;
-    protected expect(): Promise<MethodReturn<R, M>>;
-}
-declare class ResponseContext<R, M extends keyof R> extends Context<R, M> {
-    withMessage<M2 extends keyof R>(message: M2, id?: string): ResponseContext<R, M2>;
-    listen(callback: Listener<R, M, MethodArg<R, M>, ResponseContext<R, M>>): () => void;
-    send(data?: MethodReturn<R, M>): MethodReturn<R, M>;
-}
-export {};