@cgtk/std 0.0.185 → 0.0.186

package/array.d.ts

@@ -1,6 +1,8 @@
-import type { Fn, Tuple, Numbers } from "./types.js";
+import type { Fn, Tuple, Numbers } from "./types";
+export declare const empty: <T>() => T[];
 export declare const push: <T>(xs: T[], x: T) => T[];
 export declare const unshift: <T>(xs: T[], x: T) => T[];
+export declare const get: (i: number) => <T>(xs: T[]) => T;
 export declare const pop: <T>(xs: T[]) => T[];
 export declare const shift: <T>(xs: T[]) => T[];
 export declare const first: <T>(xs: T[]) => T;

package/array.js

@@ -1,6 +1,8 @@
-import { comp, scan } from "./fn.js";
+import { comp, scan } from "./fn";
+export const empty = () => [];
 export const push = (xs, x) => (xs.push(x), xs);
 export const unshift = (xs, x) => (xs.unshift(x), xs);
+export const get = (i) => (xs) => xs[i];
 export const pop = (xs) => (xs.pop(), xs);
 export const shift = (xs) => (xs.shift(), xs);
 export const first = (xs) => xs[0];
@@ -9,7 +11,7 @@ export const cap = (n, f) => xs => {
         f(xs);
     return xs;
 };
-export const retain = (n, xs = []) => comp(scan(push)(xs), cap(n, shift));
+export const retain = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
 export const tuple = (...xs) => xs;
 export const seek = (arr, vals, offset = 0) => {
     for (let i = offset, n = arr.length; i < n; i++)

package/assign.d.ts

@@ -1,4 +1,4 @@
-import type { RecordOf } from "./types.js";
+import type { RecordOf } from "./types";
 type PO = RecordOf<unknown>;
 type Merge<T extends PO, S extends PO> = {
     [K in keyof (T & S)]: K extends keyof S ? (K extends keyof T ? (S[K] extends PO ? (T[K] extends PO ? Merge<T[K], S[K]> : S[K]) : S[K]) : S[K]) : (K extends keyof T ? T[K] : never);

package/assign.js

@@ -1,4 +1,4 @@
-import { isUndefined, isNull } from "./checks.js";
+import { isUndefined, isNull } from "./checks";
 const isPrimitive = (x) => {
     const t = typeof x;
     return t === "string" || t === "number" || t === "boolean";

package/async.d.ts

@@ -1,5 +1,8 @@
-import type { Fn, Constantly, Optional } from "./types.js";
+import type { Fn, Constantly, Optional, Dispose, MaybePromise } from "./types";
 export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
 export declare const delay: (ms: number) => <T>(x: T) => Promise<T>;
 export declare const probing: <T>(p: Promise<T>) => Constantly<Optional<T>>;
 export declare const resolved: <T>(p: Promise<T>) => (f: Fn<T>) => () => void;
+export declare const promise: <T>(x: MaybePromise<T>) => Promise<any>;
+export declare const then: <T>(p: Promise<T>) => <R>(f: Fn<T, R>) => Promise<R>;
+export declare const dispose: (p: Promise<Dispose>) => Dispose;

package/async.js

@@ -1,5 +1,5 @@
-import { filterT } from "./fn.js";
-import { isDefined } from "./checks.js";
+import { filterT, disposable } from "./fn";
+import { isDefined } from "./checks";
 export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
         reject(signal.reason);
@@ -25,3 +25,6 @@ export const resolved = (p) => {
         return () => g(val());
     };
 };
+export const promise = (x) => (x instanceof Promise) ? x : Promise.resolve(x);
+export const then = (p) => (f) => p.then(f);
+export const dispose = (p) => disposable(async (dispose) => dispose(await p));

package/checks.d.ts

@@ -1,6 +1,5 @@
-import type { TypedArray, TypedArrayConstructor, Pred, TPred, FnV, Optional, Numbers } from "./types";
+import type { TypedArray, Pred, TPred, Optional, Numbers } from "./types";
 export declare const isTypedArray: (x: any) => x is TypedArray;
-export declare const isTypedArrayConstructor: (x: any) => x is TypedArrayConstructor;
 export declare const isUndefined: (x: any) => x is undefined;
 export declare const isNull: (x: any) => x is null;
 export declare const isDefined: <T>(x: Optional<T>) => x is T;
@@ -13,10 +12,10 @@ export declare const isPositive: Pred<number>;
 export declare const isTs: <T>(p: TPred<T>) => TPred<T[]>;
 export declare const isclose: (a: number, b: number, eps?: number) => boolean;
 export declare const allclose: (a: Numbers, b: Numbers, eps?: number) => boolean;
-export declare const ternary: <A, B, C>(f: FnV<[A, B], C>) => (a: Optional<A>, b: Optional<B>) => C;
 export declare const equal: <T>(a: T, b?: T) => boolean;
 export declare const strictEqual: <T>(a: T, b?: T) => boolean;
 export declare const isDiffPrev: <T>(eq?: (a: T, b?: T | undefined) => boolean) => Pred<T>;
+export declare const isLonger: <T>(delta: number) => Pred<T>;
 export declare const isFunction: <T extends Function>(x: any) => x is T;
 export declare const isAborted: (signal: AbortSignal) => () => boolean;
 export declare const isArrayBufferLike: (x: any) => x is ArrayBufferLike;
@@ -24,3 +23,4 @@ export declare const isArrayBufferView: (x: any) => x is ArrayBufferView;
 export declare const isEmpty: (x: {
     length: number;
 }) => boolean;
+export declare const counted: (n: number) => () => boolean;

package/checks.js

@@ -4,10 +4,6 @@ export const isTypedArray = (x) => x && (x instanceof Uint8Array || x instanceof
     x instanceof Uint16Array || x instanceof Uint32Array ||
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
     x instanceof Float32Array || x instanceof Float64Array);
-export const isTypedArrayConstructor = (x) => x && (x == Uint8Array || x == Uint8ClampedArray ||
-    x == Uint16Array || x == Uint32Array ||
-    x == Int8Array || x == Int16Array || x == Int32Array ||
-    x == Float32Array || x == Float64Array);
 export const isUndefined = (x) => x === undefined;
 export const isNull = (x) => x === null;
 export const isDefined = (x) => !isUndefined(x);
@@ -23,10 +19,10 @@ export const isPositive = (x) => x > 0;
 export const isTs = (p) => and(Array.isArray, (xs) => xs.every(p));
 export const isclose = (a, b, eps = Number.EPSILON) => Math.abs(a - b) < eps;
 export const allclose = (a, b, eps) => a.length == b.length && a.every((x, i) => isclose(x, b[i], eps));
-export const ternary = (f) => (a, b) => ((!isUndefined(a) && !isUndefined(b)) ? f(a, b) : isUndefined(a) ? b : a);
 export const equal = (a, b) => a == b;
 export const strictEqual = (a, b) => a === b;
 export const isDiffPrev = (eq = (strictEqual)) => comp(retain(2), not(apply(eq)));
+export const isLonger = (delta) => comp((x) => [performance.now(), x], retain(2), (xs) => xs.length < 2 || xs[1][0] - xs[0][0] > delta);
 export const isFunction = (x) => typeof x === "function";
 export const isAborted = (signal) => () => signal.aborted;
 export const isArrayBufferLike = (x) => x instanceof ArrayBuffer || x instanceof SharedArrayBuffer;
@@ -35,3 +31,7 @@ export const isArrayBufferView = (x) => x != null &&
     isNumber(x.byteOffset) &&
     isNumber(x.byteLength);
 export const isEmpty = (x) => x.length == 0;
+export const counted = (n) => {
+    let m = 0;
+    return () => m++ < n;
+};

package/dom.d.ts

@@ -1,39 +1,50 @@
-import type { Fn } from "./types.js";
+import type { Fn, Dispose, RecordOf, Optional } from "./types";
 export declare const customEvent: <T>(type: string, detail: T, { composed, bubbles, cancelable }?: EventInit) => CustomEvent<T>;
+type ListenOpts = boolean | AddEventListenerOptions;
 export declare const on: {
-    <T extends HTMLElement, K extends keyof HTMLElementEventMap>(el: T, name: K, listener: Fn<HTMLElementEventMap[K]>, opts?: boolean | AddEventListenerOptions): Fn<void>;
-    <T extends SVGGraphicsElement, K extends keyof SVGElementEventMap>(el: T, name: K, listener: Fn<SVGElementEventMap[K]>, opts?: boolean | AddEventListenerOptions): Fn<void>;
-    <K extends keyof DocumentEventMap>(el: Document, name: K, listener: Fn<DocumentEventMap[K]>, opts?: boolean | AddEventListenerOptions): Fn<void>;
-    <K extends keyof WindowEventMap>(el: Window, name: K, listener: Fn<WindowEventMap[K]>, opts?: boolean | AddEventListenerOptions): Fn<void>;
-    <K extends keyof AbortSignalEventMap>(el: AbortSignal, name: K, listener: Fn<AbortSignalEventMap[K]>, opts?: boolean | AddEventListenerOptions): Fn<void>;
+    <T extends HTMLElement, K extends keyof HTMLElementEventMap>(el: T, name: K, listener: Fn<HTMLElementEventMap[K]>, opts?: ListenOpts): Dispose;
+    <T extends SVGGraphicsElement, K extends keyof SVGElementEventMap>(el: T, name: K, listener: Fn<SVGElementEventMap[K]>, opts?: ListenOpts): Dispose;
+    <T, K extends keyof MessageEventTargetEventMap>(el: MessageEventTarget<T>, name: K, listener: Fn<MessageEventTargetEventMap[K]>, opts?: ListenOpts): Dispose;
+    <K extends keyof DocumentEventMap>(el: Document, name: K, listener: Fn<DocumentEventMap[K]>, opts?: ListenOpts): Dispose;
+    <K extends keyof WindowEventMap>(el: Window, name: K, listener: Fn<WindowEventMap[K]>, opts?: ListenOpts): Dispose;
+    <K extends keyof WorkerEventMap>(el: Worker, name: K, listener: Fn<WorkerEventMap[K]>, opts?: ListenOpts): Dispose;
+    <K extends keyof AbortSignalEventMap>(el: AbortSignal, name: K, listener: Fn<AbortSignalEventMap[K]>, opts?: ListenOpts): Dispose;
 };
 export declare const onAll: {
     <T extends keyof HTMLElementEventMap>(el: HTMLElement, listeners: {
         [k in T]: Fn<HTMLElementEventMap[k]>;
-    }, opts?: boolean | AddEventListenerOptions): Fn<void>;
+    }, opts?: ListenOpts): Dispose;
     <T extends keyof SVGElementEventMap>(el: SVGGraphicsElement, listeners: {
         [k in T]: Fn<SVGElementEventMap[k]>;
-    }, opts?: boolean | AddEventListenerOptions): Fn<void>;
+    }, opts?: ListenOpts): Dispose;
+    <T, K extends keyof MessageEventTargetEventMap>(el: MessageEventTarget<T>, listeners: {
+        [k in K]: Fn<MessageEventTargetEventMap[k]>;
+    }, opts?: ListenOpts): Dispose;
     <T extends keyof DocumentEventMap>(el: Document, listeners: {
         [k in T]: Fn<DocumentEventMap[k]>;
-    }, opts?: boolean | AddEventListenerOptions): Fn<void>;
+    }, opts?: ListenOpts): Dispose;
     <T extends keyof WindowEventMap>(el: Window, listeners: {
         [k in T]: Fn<WindowEventMap[k]>;
-    }, opts?: boolean | AddEventListenerOptions): Fn<void>;
+    }, opts?: ListenOpts): Dispose;
+    <T extends keyof WorkerEventMap>(el: Worker, listeners: {
+        [k in T]: Fn<WorkerEventMap[k]>;
+    }, opts?: ListenOpts): Dispose;
     <T extends keyof AbortSignalEventMap>(el: AbortSignal, listeners: {
         [k in T]: Fn<AbortSignalEventMap[k]>;
-    }, opts?: boolean | AddEventListenerOptions): Fn<void>;
+    }, opts?: ListenOpts): Dispose;
 };
 type DragHandlers = Record<'down' | 'move' | 'up', Fn<PointerEvent>>;
 export declare const onDrag: {
-    (el: HTMLElement, fns: Partial<DragHandlers>): Fn<void>;
-    (el: SVGGraphicsElement, fns: Partial<DragHandlers>): Fn<void>;
+    (el: HTMLElement, fns: Partial<DragHandlers>): Dispose;
+    (el: SVGGraphicsElement, fns: Partial<DragHandlers>): Dispose;
 };
 export declare const onDragMove: {
-    (el: HTMLElement, f: Fn<PointerEvent>): Fn<void>;
-    (el: SVGGraphicsElement, f: Fn<PointerEvent>): Fn<void>;
+    (el: HTMLElement, f: Fn<PointerEvent>): Dispose;
+    (el: SVGGraphicsElement, f: Fn<PointerEvent>): Dispose;
 };
-export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, options?: ResizeObserverOptions) => () => void;
+export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, options?: ResizeObserverOptions) => Dispose;
 export declare const preventDefault: <T extends Event>(e: T) => void;
 export declare const loadImage: (img: HTMLImageElement, src: string) => Promise<HTMLImageElement>;
+export declare const pushState: (path: string, query?: RecordOf<string>, data?: any) => void;
+export declare const qs: (search?: string) => Optional<RecordOf<string>>;
 export {};

package/dom.js

@@ -1,5 +1,6 @@
-import { forEach, noop } from "./fn.js";
-import { EMPTY } from "./constants.js";
+import { forEach, noop } from "./fn";
+import { isDefined } from "./checks";
+import { EMPTY } from "./constants";
 export const customEvent = (type, detail, { composed = false, bubbles = false, cancelable = false } = EMPTY.OBJ) => new CustomEvent(type, { bubbles, cancelable, composed, detail });
 export const on = (el, name, listener, opts = false) => {
     el.addEventListener(name, listener, opts);
@@ -29,3 +30,7 @@ export const loadImage = (img, src) => new Promise((resolve) => {
     const off = on(img, "load", () => (off(), resolve(img)));
     img.src = src;
 });
+export const pushState = (path, query, data) => history.pushState(data, EMPTY.STR, isDefined(query) ? `${path}?${new URLSearchParams(query).toString()}` : path);
+export const qs = (search = location.search) => search.length > 0
+    ? Object.fromEntries(new URLSearchParams(search).entries())
+    : undefined;

package/fn.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Optional } from "./types.js";
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Optional, Dispose, Reactive } from "./types";
 export declare const tee: <T>(f: Fn<T, void>) => Fn<T, T>;
 export declare const comp: <Fs extends Fn[]>(...fs: Fs) => (x: FirstParam<Fs[0]>) => Last<Fs> extends Fn<any, infer R> ? R : never;
 export declare const pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
@@ -15,15 +15,19 @@ export declare const apply: <F extends FnV>(f: F) => (x: Parameters<F>) => Retur
 export declare const call: <T extends unknown[]>(f: Fn<T>) => (...xs: T) => ReturnType<typeof f>;
 export declare const bind: <A extends unknown[], B extends unknown[], R>(f: (...args: [...A, ...B]) => R, ...args: A) => (...args: B) => R;
 export declare const lazy: <F extends FnV>(f: F, ...xs: Parameters<F>) => Fn<void, ReturnType<F>>;
-export declare const idempotent: <F extends FnV<any[], Fn<void> | any>>(f: F) => (...xs: Parameters<F>) => void;
 export declare const where: <T, U, V>(p: Pred<T>, f: Fn<T, U>, g: Fn<T, V>) => (x: T) => U | V;
-export declare const before: <F extends Fn<void>>(f: F) => <G extends FnV>(g: G) => (...xs: Parameters<G>) => ReturnType<G>;
+export declare const before: <F extends Fn<void>>(f: F) => FnF;
 export declare const after: <F extends Fn<void>>(f: F) => FnF;
 export declare const mapForEach: <T, R>(...fs: Fn<T, Fn<R>>[]) => (x: T) => (x: R) => void;
 export declare const filter: <T>(p: Pred<T>, f: Fn<T>) => (x: T) => void;
 export declare const filterT: <T>(p: TPred<T>, f: Fn<T>) => <S>(x: S) => void;
-export declare const scan: <T, S>(f: FnV<[S, T], S>) => Fn<S, Fn<T, S>>;
+export declare const scan: <T, S>(f: FnV<[S, T], S>, a: S) => Fn<T, S>;
 export declare const memoize: <T extends any[], K, V>(f: FnV<T, V>, key?: FnV<T, K>, cache?: Map<K, V>) => (...xs: T) => NonNullable<V>;
-export declare const abortable: (f: Fn<AbortSignal>) => <T = any>(reason?: T) => void;
-export declare const disposable: (f: Fn<Fn<Fn<void>, Fn<void>>>, disposes?: Set<Fn<void>>) => () => void;
-export declare const disposing: () => <F extends FnV<any[], Optional<Fn<void>>>>(f: F) => (...xs: Parameters<F>) => Fn<void>;
+export declare const abortable: <T = any>(f: Fn<AbortSignal>, reason?: T) => () => void;
+export declare const disposable: (f: Fn<Fn<Dispose, Dispose>>, disposes?: Set<Dispose>) => Dispose;
+export declare const disposing: () => <F extends FnV<any[], Optional<Dispose>>>(f: F) => FnV<Parameters<F>, Dispose>;
+export declare const disposeWith: <T>(f: Fn<T, Dispose>) => (g: Fn<Fn<T>>) => Dispose;
+export declare const idemp: <F extends FnV<any[], Dispose | void>>(d: Fn<Dispose, Dispose>, f: F) => FnV<Parameters<F>, Dispose>;
+export declare const toggler: (f: Fn<void, Dispose>) => (x: boolean) => Dispose;
+export declare const voidify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => void;
+export declare const effectual: <T>(f: Reactive<T>, g: Fn<T>) => Dispose;

package/fn.js

@@ -1,3 +1,4 @@
+import { add } from "./set";
 export const tee = f => x => (f(x), x);
 export const comp = (...fs) => (x) => fs.reduce((x, f) => f(x), x);
 export const pipe = (x, ...fs) => fs.reduce((x, f) => f(x), x);
@@ -14,16 +15,8 @@ export const apply = (f) => (x) => f.apply(null, x);
 export const call = (f) => (...xs) => f(xs);
 export const bind = (f, ...args) => f.bind(null, ...args);
 export const lazy = (f, ...xs) => () => f(...xs);
-export const idempotent = (f) => {
-    let clear = noop;
-    return (...xs) => {
-        clear();
-        const y = f(...xs);
-        clear = typeof y === "function" ? y : noop;
-    };
-};
 export const where = (p, f, g) => (x) => p(x) ? f(x) : g(x);
-export const before = (f) => (g) => (...xs) => (f(), g(...xs));
+export const before = (f) => g => (...xs) => (f(), g(...xs));
 export const after = (f) => g => (...xs) => {
     const r = g(...xs);
     f();
@@ -34,23 +27,35 @@ export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
 export const filterT = (p, f) => (x) => { if (p(x))
     f(x); };
-export const scan = (f) => (a) => (x) => a = f(a, x);
+export const scan = (f, a) => (x) => a = f(a, x);
 export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs) => {
     const k = key(...xs);
     if (!cache.has(k))
         cache.set(k, f(...xs));
     return cache.get(k);
 };
-export const abortable = (f) => {
+export const abortable = (f, reason) => {
     const ctrl = new AbortController();
     f(ctrl.signal);
-    return (reason) => ctrl.abort(reason);
+    return () => ctrl.abort(reason);
 };
 export const disposable = (f, disposes = new Set()) => {
-    f(g => (disposes.add(g), () => disposes.delete(g)));
+    f(bind(add, disposes));
     return () => (disposes.forEach(g => g()), disposes.clear());
 };
 export const disposing = () => {
     let dispose = noop;
-    return (f) => (...xs) => (dispose(), dispose = f(...xs) ?? noop);
+    const stop = () => dispose();
+    return (f) => (...xs) => (stop(), dispose = f(...xs) ?? noop, stop);
+};
+export const disposeWith = (f) => (g) => disposable((d) => g(comp(f, d)));
+export const idemp = (d, f) => disposing()((...xs) => {
+    const cleanup = f(...xs) ?? noop;
+    return forEach(cleanup, d(cleanup));
+});
+export const toggler = (f) => {
+    let cancel = noop;
+    return (x) => (cancel(), (cancel = x ? f() : noop));
 };
+export const voidify = (f) => (...xs) => { f(...xs); };
+export const effectual = (f, g) => disposable(d => d(f(idemp(d, g))));

package/http.d.ts

@@ -5,5 +5,6 @@ export declare const fetchBuffer: (url: string, init?: RequestInit) => Promise<U
 export declare const fetchText: (url: string, init?: RequestInit) => Promise<string>;
 export declare const fetchDOM: (url: string, init?: RequestInit) => Promise<HTMLElement>;
 export declare const fetchImage: (src: string) => Promise<HTMLImageElement>;
+export declare const fetchImageBitmap: (url: string, init?: RequestInit) => Promise<ImageBitmap>;
 export declare const fetchJSON: (url: string, init?: RequestInit) => Promise<any>;
 export declare const fetchDataUrl: (url: string) => Promise<string>;

package/http.js

@@ -22,6 +22,11 @@ export const fetchImage = (src) => new Promise((resolve, reject) => {
     image.onload = () => resolve(image);
     image.onerror = reject;
 });
+export const fetchImageBitmap = async (url, init) => {
+    const res = await fetch(url, init);
+    const blob = await res.blob();
+    return await createImageBitmap(blob, { colorSpaceConversion: "none" });
+};
 export const fetchJSON = (url, init) => fetchBuffer(url, init).then(fromBytes);
 export const fetchDataUrl = (url) => fetch(url)
     .then(resp => resp.blob())

package/iterable.d.ts

@@ -19,6 +19,7 @@ export declare const prepend: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<
 export declare const append: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const first: <T>(xs: IteratorObject<T>) => T | undefined;
 export declare const reduce: <T, S>(f: FnV<[S, T, number], S>, a: S) => (xs: IteratorObject<T>) => S;
+export declare const reduceRec: <T, A, R>(xs: IteratorObject<T>, f: FnV<[A, T, Fn<A>], R>, o: A, result: Fn<A, R>) => R;
 export declare const traverse: <T>(children: Fn<T, Iterable<T>>, f: Fn<T>) => Fn<T>;
 export declare const take: (n: number) => <T>(xs: IteratorObject<T>) => Generator<T>;
 export declare function arange(a: number, b?: number, s?: number): Generator<number, void, unknown>;

package/iterable.js

@@ -29,6 +29,16 @@ export const prepend = (ys) => (xs) => concat(ys, xs);
 export const append = (ys) => (xs) => concat(xs, ys);
 export const first = (xs) => xs.find(constantly(true));
 export const reduce = (f, a) => (xs) => xs.reduce(f, a);
+export const reduceRec = (xs, f, o, result) => {
+    const next = (o) => {
+        const { done, value } = xs.next();
+        if (done)
+            return result(o);
+        else
+            return f(o, value, next);
+    };
+    return next(o);
+};
 export const traverse = (children, f) => (x) => (f(x), forEach(traverse(children, f))(Iterator.from(children(x))));
 export const take = n => function* (xs) {
     for (let i = 0; i < n; i++) {
@@ -129,7 +139,7 @@ export const untilA = (p) => async function* (xs) {
     }
 };
 export const reduceA = (f, a) => async (xs) => {
-    const g = scan(f)(a);
+    const g = scan(f, a);
     await forEachA()(mapA((x) => a = g(x))(xs));
     return a;
 };

package/map.d.ts

@@ -1,10 +1,9 @@
-import type { Fn, FnV, Optional } from "./types.js";
-export declare const map: <T, V, K = any>({ create, update, remove }: {
-    create: FnV<[T, K, Map<K, V>], V>;
-    update: FnV<[V, T, K, Map<K, V>], V>;
+import type { FnV, Optional } from "./types";
+export declare const transform: <K, S, V>({ create, update, remove }: {
+    create: FnV<[S, K, Map<K, V>], V>;
+    update: FnV<[V, S, K, Map<K, V>], V>;
     remove?: FnV<[V, K, Map<K, V>]>;
-}) => (dst?: Map<K, V>) => (src: Map<K, T>) => Map<K, V>;
-export declare const mapAlloc: <T, S, K = any>(f: FnV<[T, S]>, alloc: Fn<void, T>, remove?: FnV<[T, K, Map<K, T>]>) => (dst?: Map<K, T>) => (src: Map<K, S>) => Map<K, T>;
+}, dst?: Map<K, V>) => (src: Map<K, S>) => Map<K, V>;
 export declare const set: <K, V>(m: Map<K, V>, [i, x]: [K, V]) => Map<K, V>;
 export declare const get: <K, V>(m: Map<K, V>, k: K, d: V) => V;
 export declare const update: <K, V>(m: Map<K, V>, k: K, f: FnV<[V | undefined, K, Map<K, V>], V>) => Map<K, V>;

package/map.js

@@ -1,6 +1,6 @@
-import { isDefined } from "./checks.js";
-import * as I from "./iterable.js";
-export const map = ({ create, update, remove }) => (dst = new Map()) => (src) => {
+import { isDefined } from "./checks";
+import * as I from "./iterable";
+export const transform = ({ create, update, remove }, dst = new Map()) => (src) => {
     for (const k of dst.keys())
         if (!src.has(k)) {
             remove && remove(dst.get(k), k, dst);
@@ -14,7 +14,6 @@ export const map = ({ create, update, remove }) => (dst = new Map()) => (src) =>
     });
     return dst;
 };
-export const mapAlloc = (f, alloc, remove) => map({ create: e => f(alloc(), e), update: f, remove });
 export const set = (m, [i, x]) => (m.set(i, x), m);
 export const get = (m, k, d) => m.has(k) ? m.get(k) : d;
 export const update = (m, k, f) => set(m, [k, f(m.get(k), k, m)]);

package/math.d.ts

@@ -10,6 +10,7 @@ export declare const FOUR_OVER_PI: number;
 export declare const INV_PI: number;
 export declare const INV_TAU: number;
 export declare const INV_HALF_PI: number;
+export declare const U32_MAX = 4294967295;
 export declare const EPS: number;
 export declare const radians: (x: number) => number;
 export declare const degrees: (x: number) => number;
@@ -29,3 +30,5 @@ export declare const logn: (n: number, x: number) => number;
 export declare const floordiv: (x: number, b: number) => number;
 export declare const zoom: (x: number, s: number, p: number) => number;
 export declare const align: (x: number, b: number) => number;
+export declare const sign11: (x: number) => 1 | -1;
+export declare const nudge: (x: number, v?: number, eps?: number) => number;

package/math.js

@@ -1,3 +1,4 @@
+import { isclose } from "./checks";
 export const PI = Math.PI;
 export const TAU = PI * 2;
 export const HALF_PI = PI / 2;
@@ -10,6 +11,7 @@ export const FOUR_OVER_PI = 4 / Math.PI;
 export const INV_PI = 1 / PI;
 export const INV_TAU = 1 / TAU;
 export const INV_HALF_PI = 1 / HALF_PI;
+export const U32_MAX = 0xFFFFFFFF;
 export const EPS = Number.EPSILON;
 const DEG2RAD = PI / 180, RAD2DEG = 180 / PI;
 export const radians = (x) => x * DEG2RAD;
@@ -37,3 +39,5 @@ export const logn = (n, x) => Math.log(x) / Math.log(n);
 export const floordiv = (x, b) => Math.floor(x / b + (x < 0 ? 1 : 0));
 export const zoom = (x, s, p) => (x - p) * s + p;
 export const align = (x, b) => (x + b - 1) & -b;
+export const sign11 = (x) => x >= 0 ? 1 : -1;
+export const nudge = (x, v = 0, eps = EPS) => isclose(x, v, eps) ? sign11(x - v) * eps + v : x;

package/npy.d.ts

@@ -0,0 +1,10 @@
+import type { TypedArray, Elements } from "./types";
+declare const DTYPES: readonly ["|u1", "<u2", "<u4", "|i1", "<i2", "<i4", "<f4", "<f8"];
+type DType = Elements<typeof DTYPES>;
+export interface NDArray {
+    data: TypedArray;
+    dtype: DType;
+    shape: number[];
+}
+export declare const read: (buf: ArrayBuffer) => NDArray;
+export {};

package/npy.js

@@ -0,0 +1,29 @@
+const DTYPES = [
+    "|u1", "<u2", "<u4",
+    "|i1", "<i2", "<i4",
+    "<f4", "<f8",
+    // "<u8", "<i8", 
+];
+const TYPED_ARRAY = {
+    "|u1": Uint8Array,
+    "<u2": Uint16Array,
+    "<u4": Uint32Array,
+    "|i1": Int8Array,
+    "<i2": Int16Array,
+    "<i4": Int32Array,
+    "<f4": Float32Array,
+    "<f8": Float64Array,
+    // "<u8": BigUint64Array,
+    // "<i8": BigInt64Array,
+};
+export const read = (buf) => {
+    const headerLength = new DataView(buf.slice(8, 10)).getUint8(0);
+    const hcontents = new TextDecoder("utf-8").decode(buf.slice(10, 10 + headerLength));
+    const { descr, shape } = JSON.parse(hcontents
+        .replace(/'/g, '"')
+        .replace("False", "false")
+        .replace("(", "[")
+        .replace(/,*\),*/g, "]"));
+    const data = new TYPED_ARRAY[descr](buf, headerLength + 10);
+    return { data, shape, dtype: descr };
+};

package/number.d.ts

@@ -1,2 +1,3 @@
 export declare const add: (a: number, x: number) => number;
 export declare const toFixedMax: (x: number, n?: number) => string;
+export declare const roundTo: (x: number, n: number) => number;

package/number.js

@@ -3,3 +3,9 @@ export const toFixedMax = (x, n = 0) => {
     const y = Number(x.toFixed(n));
     return `${Math.sign(y) == -1 ? '-' : ''}${Math.abs(y)}`;
 };
+export const roundTo = (x, n) => {
+    const inv = 1. / n;
+    const result = Math.round(x * inv) / inv;
+    const decimals = n.toString().split(".")[1]?.length || 0;
+    return parseFloat(result.toFixed(decimals));
+};

package/object.d.ts

@@ -1,11 +1,13 @@
-import type { RecordOf, Elements, Optional, Fn, FnV } from "./types.js";
-export declare const mapEntries: <S, T = S>(f: FnV<[[string, S], number], [string, T]>) => Fn<RecordOf<S>, RecordOf<T>>;
-export declare const mapValues: <S, T = S>(f: FnV<[S, string, number], T>) => Fn<RecordOf<S>, RecordOf<T>>;
-export declare const rename: <S>(keys: RecordOf<string>) => Fn<RecordOf<S>, RecordOf<S>>;
-export declare const renameWith: <S>(f: Fn<string, string>) => Fn<RecordOf<S>, RecordOf<S>>;
+import type { RecordOf, Elements, Optional, FnV, ValueOf, EntriesTuple, UnionToTuple, Entry } from "./types.js";
+export declare const entries: <T extends RecordOf<any>>(o: T) => EntriesTuple<T>;
+export declare const keys: <T extends RecordOf<any>>(o: T) => UnionToTuple<keyof T>;
+export declare const entry: <K extends PropertyKey, V>(k: K, v: V) => Entry<K, V>;
+export declare const fromEntries: <T extends Entry<PropertyKey, any>[]>(xs: T) => { [K in T[number] as K[0]]: K[1]; };
+export declare const mapEntries: <T extends RecordOf<any>, S>(o: T, f: FnV<[Entry<keyof T, ValueOf<T>>, number], Entry<keyof T, S>>) => { [K in Entry<keyof T, S> as K[0]]: K[1]; };
+export declare const mapValues: <T extends RecordOf<any>, S>(o: T, f: FnV<[ValueOf<T>, keyof T], S>) => { [K in Entry<keyof T, S> as K[0]]: K[1]; };
 export declare const pick: <T extends RecordOf<any>, R extends Array<keyof T>>(obj: T, keys: R) => Pick<T, Elements<R>>;
 export declare const omit: <T extends RecordOf<any>, R extends Array<keyof T>>(obj: T, keys: R) => Omit<T, Elements<R>>;
-export declare const assoc: <T>(a: RecordOf<T>, [k, v]: [keyof T, T]) => RecordOf<T>;
+export declare const assoc: <T extends RecordOf<any>>(a: T, [k, v]: [keyof T, ValueOf<T>]) => T;
 type Merge<T extends RecordOf<unknown>, S extends RecordOf<unknown>, V> = {
     [K in keyof (T & S)]: V;
 };

package/object.js

@@ -1,7 +1,9 @@
-export const mapEntries = (f) => obj => Object.fromEntries(Object.entries(obj).map(f));
-export const mapValues = (f) => mapEntries(([k, v], i) => [k, f(v, k, i)]);
-export const rename = (keys) => mapEntries(([k, v]) => [keys[k] ?? k, v]);
-export const renameWith = (f) => mapEntries(([k, v]) => [f(k), v]);
+export const entries = (o) => Object.entries(o);
+export const keys = (o) => Object.keys(o);
+export const entry = (k, v) => [k, v];
+export const fromEntries = (xs) => Object.fromEntries(xs);
+export const mapEntries = (o, f) => fromEntries(entries(o).map(f));
+export const mapValues = (o, f) => mapEntries(o, ([k, v]) => entry(k, f(v, k)));
 export const pick = (obj, keys) => keys.reduce((a, k) => (a[k] = obj[k], a), {});
 export const omit = (obj, keys) => pick(obj, Object.keys(obj).filter(k => !keys.includes(k)));
 export const assoc = (a, [k, v]) => (a[k] = v, a);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.185",
+  "version": "0.0.186",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -12,6 +12,7 @@
     "./signal": "./signal.js",
     "./assign": "./assign.js",
     "./map": "./map.js",
+    "./set": "./set.js",
     "./array": "./array.js",
     "./string": "./string.js",
     "./number": "./number.js",
@@ -19,7 +20,6 @@
     "./async": "./async.js",
     "./schedule": "./schedule.js",
     "./iterable": "./iterable.js",
-    "./gen": "./gen.js",
     "./tree": "./tree.js",
     "./treemap": "./treemap.js",
     "./stream": "./stream.js",
@@ -34,10 +34,14 @@
     "./struct": "./struct.js",
     "./buffer": "./buffer.js",
     "./base64": "./base64.js",
+    "./npy": "./npy.js",
+    "./port": "./port.js",
+    "./rect": "./rect.js",
+    "./resource": "./resource.js",
     "./utils": "./utils.js"
   },
   "devDependencies": {
-    "typescript": "^5.8.3"
+    "typescript": "^5.9.2"
   },
   "publishConfig": {
     "access": "public"

package/port.d.ts

@@ -0,0 +1,29 @@
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise } from "./types";
+export interface Message<K, V> {
+    type: K;
+    payload: V;
+}
+export type Port = {
+    postMessage(message: any, options?: StructuredSerializeOptions): void;
+};
+export declare const onMessages: <S extends RecordOf<any>, T = Worker>(target: MessageEventTarget<T>, fs: Fns<S>) => Dispose;
+export declare const onMessage: <K extends string, S, T = Worker>(target: MessageEventTarget<T>, name: K, f: Fn<S>) => Dispose;
+export declare const postMessages: <T extends RecordOf<any>>(port: Port) => { [k in keyof T]: FnV<[T[k], (StructuredSerializeOptions | undefined)?]>; };
+export interface Request {
+    id: number;
+    name: PropertyKey;
+    args: any;
+}
+export interface Response {
+    id: number;
+    result: any;
+}
+interface TransferableFnV<T extends any[], R> {
+    (...args: T): R;
+    transfer(ts?: Transferable[]): FnV<T, R>;
+}
+export declare const client: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: TransferableFnV<Parameters<S[k]>, Promise<ReturnType<S[k]>>>; };
+export declare const server: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: Fn<FnV<Parameters<S[k]>, MaybePromise<ReturnType<S[k]>>>, Dispose>; };
+export declare const startClient: (worker: Worker, f: Fn<Worker, Dispose | void>) => Promise<Dispose>;
+export declare const startServer: (worker: Worker, f: Fn<Worker, MaybePromise<Dispose>>) => Promise<Dispose>;
+export {};