@cgtk/std 0.0.194 → 0.0.196

package/array.d.ts

@@ -7,7 +7,8 @@ export declare const pop: <T>(xs: T[]) => T[];
 export declare const shift: <T>(xs: T[]) => T[];
 export declare const first: <T>(xs: T[]) => T;
 export declare const cap: <T>(n: number, f: Fn<T[]>) => Fn<T[], T[]>;
-export declare const retain: <T>(n: number, xs?: T[]) => (x: T) => T[];
+export declare const sliding: <T>(n: number, xs?: T[]) => (x: T) => T[];
+export declare const dropping: <T>(n: number, xs?: T[]) => (x: T) => T[];
 export declare const tuple: <T, N extends number>(...xs: T[] & {
     length: N;
 }) => Tuple<T, N>;

package/array.js

@@ -11,7 +11,8 @@ export const cap = (n, f) => xs => {
         f(xs);
     return xs;
 };
-export const retain = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
+export const sliding = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
+export const dropping = (n, xs = []) => comp(scan((push), xs), cap(n, pop));
 export const tuple = (...xs) => xs;
 export const seek = (arr, vals, offset = 0) => {
     for (let i = offset, n = arr.length; i < n; i++)

package/async.d.ts

@@ -1,8 +1,8 @@
-import type { Fn, Constantly, Maybe, Dispose, MaybePromise } from "./types.js";
+import type { Fn, Lazy, Maybe, Dispose, MaybePromise } from "./types.js";
 export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
 export declare const delay: (ms: number, signal?: AbortSignal) => <T>(x: T) => Promise<T>;
-export declare const probing: <T>(p: Promise<T>) => Constantly<Maybe<T>>;
+export declare const probing: <T>(p: Promise<T>) => Lazy<Maybe<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;
+export declare const dispose: (p: Promise<Dispose>) => () => void;

package/async.js

@@ -1,4 +1,4 @@
-import { filterT, disposable } from "./fn.js";
+import { filterT, noop } from "./fn.js";
 import { isDefined } from "./checks.js";
 export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
@@ -28,4 +28,17 @@ export const resolved = (p) => {
 };
 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));
+export const dispose = (p) => {
+    let dispose = noop;
+    let disposed = false;
+    p.then(d => {
+        if (disposed)
+            d();
+        else
+            dispose = d;
+    });
+    return () => {
+        disposed = true;
+        dispose();
+    };
+};

package/buffer.d.ts

@@ -1,14 +1,7 @@
-import type { Fn } from "./types.js";
-export interface BufReader {
-    offset: number;
-    line: Fn<void, string>;
-    u8: Fn<void, number>;
-    u16: Fn<boolean, number>;
-    u32: Fn<boolean, number>;
-    i8: Fn<void, number>;
-    i16: Fn<boolean, number>;
-    i32: Fn<boolean, number>;
-    f32: Fn<boolean, number>;
-    f64: Fn<boolean, number>;
-}
-export declare const bufReader: (data: Uint8Array, offset?: number) => BufReader;
+import type { Maybe } from "./types.js";
+export declare const fifo: <T>(n?: number) => {
+    put(x: T): Promise<number>;
+    take(): Promise<T>;
+    readonly size: number;
+    peek(): Maybe<T>;
+};

package/buffer.js

@@ -1,54 +1,28 @@
-import { readLine } from './string.js';
-export const bufReader = (data, offset = 0) => {
-    const rl = readLine();
-    const dv = new DataView(data.buffer, data.byteOffset);
+import { isDefined } from "./checks.js";
+export const fifo = (n = 1) => {
+    const data = [];
+    const pushes = [];
+    const takes = [];
     return {
-        get offset() { return offset; },
-        set offset(x) { offset = x; },
-        line() {
-            const line = rl(data, offset);
-            offset += line.length;
-            return line;
-        },
-        u8() {
-            const x = dv.getUint8(offset);
-            offset += 1;
-            return x;
-        },
-        u16(littleEndian = true) {
-            const x = dv.getUint16(offset, littleEndian);
-            offset += 2;
-            return x;
-        },
-        u32(littleEndian = true) {
-            const x = dv.getUint16(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        i8() {
-            const x = dv.getInt8(offset);
-            offset += 1;
-            return x;
-        },
-        i16(littleEndian = true) {
-            const x = dv.getInt16(offset, littleEndian);
-            offset += 2;
-            return x;
-        },
-        i32(littleEndian = true) {
-            const x = dv.getInt32(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        f32(littleEndian = true) {
-            const x = dv.getFloat32(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        f64(littleEndian = true) {
-            const x = dv.getFloat64(offset, littleEndian);
-            offset += 8;
-            return x;
-        },
+        async put(x) {
+            if (data.length >= n)
+                return new Promise(resolve => pushes.push(() => (data.push(x), resolve(data.length))));
+            const len = data.push(x);
+            const f = takes.shift();
+            if (isDefined(f))
+                f(x);
+            return Promise.resolve(len);
+        },
+        async take() {
+            if (data.length == 0)
+                return new Promise(resolve => takes.push(resolve));
+            const x = data.shift();
+            const f = pushes.shift();
+            if (isDefined(f))
+                f();
+            return Promise.resolve(x);
+        },
+        get size() { return data.length; },
+        peek() { return data[0]; }
     };
 };

package/channel.d.ts

@@ -0,0 +1,37 @@
+import type { Fn, FnV, Dispose, Structure, Pred } from "./types.js";
+export interface Channel<T> {
+    next: Fn<T>;
+    on(next: Fn<T>, done?: Dispose): Dispose;
+    done: Dispose;
+    stateful(f: Fn<T, Dispose>, done?: Dispose): Dispose;
+    to<S>(f: Fn<Channel<T>, Channel<S>>): Channel<S>;
+}
+export declare const create: <T>(subs?: Set<{
+    next: Fn<T>;
+    done: Dispose;
+}>) => Channel<T>;
+export declare const cached: <T>(ch?: Channel<T>) => Channel<T>;
+export interface Value<T> extends Channel<T> {
+    value: T;
+}
+export declare const value: <T>(x: T, ch?: Channel<T>) => Value<T>;
+export declare const pipe: <T, S>(f: Fn<Fn<S>, Fn<T>>, ch?: Channel<S>) => Fn<Channel<T>, Channel<S>>;
+export declare const map: <T, S>(f: Fn<T, S>, ch?: Channel<S>) => Fn<Channel<T>, Channel<S>>;
+export declare const filter: <T>(p: Pred<T>, ch?: Channel<T>) => Fn<Channel<T>, Channel<T>>;
+export declare const then: <T>(ch?: Channel<T>) => Fn<Channel<Promise<T>>, Channel<T>>;
+export declare const dedup: <T, S = T>(key?: Fn<T, S>, ch?: Channel<T>) => Fn<Channel<T>, Channel<T>>;
+export declare const gen: <T>(f: FnV<[Fn<T>, Dispose], Dispose | void>, ch?: Channel<T>) => Channel<T>;
+export declare const reduce: <T, S>(f: FnV<[S, T], S>, a: S, ch?: Channel<S>) => (c: Channel<T>) => Channel<S>;
+export declare const flatten: <T>(ch?: Channel<T>) => (cs: Channel<Channel<T>>) => Channel<T>;
+export declare const latest: <T>(ch?: Channel<T>) => (cs: Channel<Channel<T>>) => Channel<T>;
+export declare const microOn: <T>(ch?: Channel<T>) => Channel<T>;
+type F2C<T> = T extends Fn<infer U> ? Channel<U> : T extends readonly (infer U)[] ? readonly F2C<U>[] : {
+    [K in keyof T]: F2C<T[K]>;
+};
+export declare const derive: <T, F extends Structure<Fn<any>>>(cs: F2C<F>, f: Fn<Fn<T>, F>, ch?: Channel<T>) => Channel<T>;
+export interface Reactive<T> extends Value<T> {
+    set: Fn<T | Fn<T, T>>;
+    update: Fn<Fn<T>>;
+}
+export declare const reactive: <T>(x: T) => Reactive<T>;
+export {};

package/channel.js

@@ -0,0 +1,82 @@
+import * as F from "./fn.js";
+import { isFunction } from "./checks.js";
+import { add } from "./set.js";
+const channel = (next, on, done = F.noop) => ({
+    next, on, done,
+    to(f) { return f(this); },
+    stateful(next, done = F.noop) {
+        const swap = F.swapping();
+        return on(swap(next), swap(done));
+    },
+});
+export const create = (subs = new Set()) => channel((x) => subs.forEach(s => s.next(x)), (next, done = F.noop) => {
+    const del = add(subs, { next, done });
+    return () => del() && done();
+}, () => (subs.forEach(s => s.done()), subs.clear()));
+const None = Symbol('None');
+export const cached = (ch = create()) => {
+    let x = None;
+    return channel(y => ch.next(x = y), (next, done) => {
+        if (x !== None)
+            next(x);
+        return ch.on(next, done);
+    }, ch.done);
+};
+export const value = (x, ch = create()) => Object.defineProperties(channel(y => ch.next(x = y), (next, done) => (next(x), ch.on(next, done)), ch.done), {
+    value: {
+        enumerable: true,
+        get: () => x,
+        set: (y) => x = y
+    }
+});
+export const pipe = (f, ch = create()) => c => channel(ch.next, ch.on, c.on(f(ch.next), ch.done));
+export const map = (f, ch) => pipe(F.bind(F.comp, f), ch);
+export const filter = (p, ch) => pipe(F.bind(F.filter, p), ch);
+export const then = (ch) => pipe(next => p => p.then(next), ch);
+export const dedup = (key = F.identity, ch) => pipe(next => {
+    let x = None;
+    return (y) => {
+        const k = key(y);
+        if (k !== x)
+            next(y);
+        x = k;
+    };
+}, ch);
+export const gen = (f, ch = create()) => {
+    let ended = false;
+    let done = () => { ended = true; };
+    done = F.forEach(f(ch.next, () => done()) ?? F.noop, ch.done);
+    return ended ? channel(F.noop, F.constantly(F.noop)) : channel(ch.next, ch.on, done);
+};
+export const reduce = (f, a, ch = create()) => (c) => channel(F.noop, ch.on, c.on(F.scan(f, a), F.forEach(() => ch.next(a), ch.done)));
+export const flatten = (ch = create()) => (cs) => {
+    const ds = new Set();
+    return channel(ch.next, ch.on, cs.on(c => (ds.add(c.done), c.on(ch.next)), F.forEach(ch.done, () => ds.forEach(d => d()))));
+};
+export const latest = (ch = create()) => (cs) => channel(ch.next, ch.on, cs.stateful(c => c.on(ch.next, c.done), ch.done));
+export const microOn = (ch = create()) => channel(ch.next, (next, done = F.noop) => {
+    const ctrl = new AbortController();
+    let off = () => (ctrl.abort(), done());
+    queueMicrotask(() => off = ctrl.signal.aborted ? F.noop : ch.on(next, done));
+    return () => off();
+}, ch.done);
+const isChannel = (c) => Object.hasOwn(c, "next") && isFunction(c.next) && Object.hasOwn(c, "on") && isFunction(c.on) && Object.hasOwn(c, "next") && isFunction(c.next);
+export const derive = (cs, f, ch = create()) => {
+    let done = F.noop;
+    const rec = (cs, fs) => {
+        if (isFunction(fs) && isChannel(cs))
+            return cs.on(fs, () => done());
+        else if (Array.isArray(cs) && Array.isArray(fs))
+            return F.forEach(...cs.map((c, i) => rec(c, fs[i])));
+        return F.forEach(...Object.entries(cs).map(([k, v]) => rec(v, fs[k])));
+    };
+    done = F.forEach(rec(cs, f(ch.next)), ch.done);
+    return channel(ch.next, ch.on, done);
+};
+export const reactive = (x) => {
+    const ch = value(x);
+    return Object.assign(ch, {
+        set: (y) => ch.next(isFunction(y) ? y(ch.value) : y),
+        update: (f) => (f(ch.value), ch.next(ch.value)),
+    });
+};

package/checks.d.ts

@@ -2,6 +2,7 @@ import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from ".
 export declare const isTypedArray: (x: any) => x is TypedArray;
 export declare const isNumberArray: (x: any) => x is NumberArray;
 export declare const isBigIntArray: (x: any) => x is BigIntArray;
+export declare const isBoolean: (x: any) => x is boolean;
 export declare const isUndefined: (x: any) => x is undefined;
 export declare const isNull: (x: any) => x is null;
 export declare const isDefined: <T>(x: Maybe<T>) => x is T;

package/checks.js

@@ -1,5 +1,5 @@
 import { comp, not, apply, and } from "./fn.js";
-import { retain } from "./array.js";
+import { sliding } from "./array.js";
 export const isTypedArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
     x instanceof Uint16Array || x instanceof Uint32Array ||
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
@@ -10,6 +10,7 @@ export const isNumberArray = (x) => x && (x instanceof Uint8Array || x instanceo
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
     x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array);
 export const isBigIntArray = (x) => x && (x instanceof BigUint64Array || x instanceof BigInt64Array);
+export const isBoolean = (x) => typeof x === "boolean";
 export const isUndefined = (x) => x === undefined;
 export const isNull = (x) => x === null;
 export const isDefined = (x) => !isUndefined(x);
@@ -28,8 +29,8 @@ 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 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 isDiffPrev = (eq = (strictEqual)) => comp(sliding(2), not(apply(eq)));
+export const isLonger = (delta) => comp((x) => [performance.now(), x], sliding(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;

package/dom.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Dispose, RecordOf, Maybe } from "./types.js";
+import type { Fn, FnV, Dispose, RecordOf, Maybe } from "./types.js";
 export declare const customEvent: <T>(type: string, detail: T, { composed, bubbles, cancelable }?: EventInit) => CustomEvent<T>;
 type ListenOpts = boolean | AddEventListenerOptions;
 export declare const on: {
@@ -36,15 +36,34 @@ export declare const onAll: {
 type DragHandlers = Record<'down' | 'move' | 'up', Fn<PointerEvent>>;
 export declare const onDrag: {
     (el: HTMLElement, fns: Partial<DragHandlers>): Dispose;
-    (el: SVGGraphicsElement, fns: Partial<DragHandlers>): Dispose;
+    (el: SVGElement, fns: Partial<DragHandlers>): Dispose;
 };
+export declare const onDragX: (el: HTMLElement, f: Fn<number>) => Dispose;
 export declare const onDragMove: {
     (el: HTMLElement, f: Fn<PointerEvent>): Dispose;
     (el: SVGGraphicsElement, f: Fn<PointerEvent>): Dispose;
 };
 export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, options?: ResizeObserverOptions) => Dispose;
+export declare const onSelectChange: <T extends string>(el: HTMLSelectElement, f: FnV<[T, number]>, opts?: ListenOpts) => 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) => Maybe<RecordOf<string>>;
+export declare const imageData: (img: HTMLImageElement) => ImageData;
+export type Child = ChildNode | string;
+export declare const append: (el: ParentNode, ...children: Child[]) => () => void;
+export type Attribs = Record<string, string | number | boolean>;
+export declare const setAttrs: (el: Element, attrs: Attribs) => void;
+export declare const css: (styles: Record<string, {
+    toString(): string;
+}>) => string;
+export declare const style: <E extends HTMLElement>(el: E, props: Record<string, {
+    toString(): string;
+}>) => E;
+type Tags<T> = {
+    [K in keyof T]: (attrs?: Attribs | Child, ...rest: Child[]) => T[K];
+};
+export declare const h: Tags<HTMLElementTagNameMap>;
+export declare const s: Tags<SVGElementTagNameMap>;
+export declare const m: Tags<MathMLElementTagNameMap>;
 export {};

package/dom.js

@@ -1,13 +1,13 @@
-import { forEach, noop } from "./fn.js";
-import { isDefined } from "./checks.js";
+import * as F from "./fn.js";
+import { isDefined, isString, isBoolean } from "./checks.js";
 import { EMPTY } from "./constants.js";
 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);
     return () => el.removeEventListener(name, listener, opts);
 };
-export const onAll = (el, fs, opts) => forEach(...Object.keys(fs).map(k => on(el, k, fs[k], opts)));
-export const onDrag = (el, { down = noop, move = noop, up = noop }) => on(el, 'pointerdown', e => {
+export const onAll = (el, fs, opts) => F.forEach(...Object.keys(fs).map(k => on(el, k, fs[k], opts)));
+export const onDrag = (el, { down = F.noop, move = F.noop, up = F.noop }) => on(el, 'pointerdown', e => {
     const pointerId = e.pointerId;
     el.setPointerCapture(pointerId);
     down(e);
@@ -19,12 +19,18 @@ export const onDrag = (el, { down = noop, move = noop, up = noop }) => on(el, 'p
         offUp();
     });
 });
+export const onDragX = (el, f) => onDrag(el, {
+    down: e => f(e.offsetX / el.clientWidth),
+    move: e => f(e.offsetX / el.clientWidth),
+    up: e => f(e.offsetX / el.clientWidth),
+});
 export const onDragMove = (el, move) => onDrag(el, { move });
 export const onResize = (el, f, options) => {
     const ro = new ResizeObserver(f);
     ro.observe(el, options);
     return () => ro.disconnect();
 };
+export const onSelectChange = (el, f, opts) => on(el, "change", () => f(el.value, el.selectedIndex), opts);
 export const preventDefault = (e) => e.preventDefault();
 export const loadImage = (img, src) => new Promise((resolve) => {
     const off = on(img, "load", () => (off(), resolve(img)));
@@ -34,3 +40,60 @@ export const pushState = (path, query, data) => history.pushState(data, EMPTY.ST
 export const qs = (search = location.search) => search.length > 0
     ? Object.fromEntries(new URLSearchParams(search).entries())
     : undefined;
+export const imageData = (img) => {
+    const ctx = new OffscreenCanvas(img.width, img.height).getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height);
+};
+export const append = (el, ...children) => {
+    const els = children.map(x => isString(x) ? document.createTextNode(x) : x);
+    el.append(...els);
+    return () => els.forEach(x => x.remove());
+};
+export const setAttrs = (el, attrs) => Object.entries(attrs).forEach(([k, v]) => {
+    if (isBoolean(v)) {
+        if (el instanceof HTMLInputElement) {
+            if (k === "checked")
+                el.checked = v;
+            if (k === "disabled")
+                el.disabled = v;
+        }
+        else {
+            el.toggleAttribute(k, v);
+        }
+    }
+    else
+        el.setAttribute(k, v.toString());
+});
+export const css = (styles) => Object.entries(styles).map(([prop, value]) => `${prop}: ${value};`).join('');
+export const style = (el, props) => (Object.entries(props).forEach(([k, v]) => el.style.setProperty(k, v.toString())), el);
+const isAttrs = (obj) => (obj !== null &&
+    typeof obj === 'object' &&
+    !(obj instanceof Node) &&
+    !Array.isArray(obj));
+const element = (el, attrs, ...rest) => {
+    if (isDefined(attrs)) {
+        let children = rest;
+        if (isAttrs(attrs))
+            setAttrs(el, attrs);
+        else
+            children = [attrs, ...children];
+        append(el, ...children);
+    }
+    return el;
+};
+const NS = {
+    HTML: "http://www.w3.org/1999/xhtml",
+    SVG: "http://www.w3.org/2000/svg",
+    MathML: "http://www.w3.org/1998/Math/MathML",
+};
+const tag = (ns, name) => document.createElementNS(NS[ns], name);
+export const h = new Proxy({}, ({
+    get: (_, name) => F.bind((element), tag("HTML", name))
+}));
+export const s = new Proxy({}, {
+    get: (_, name) => F.bind((element), tag("SVG", name))
+});
+export const m = new Proxy({}, {
+    get: (_, name) => F.bind((element), tag("MathML", name))
+});

package/fn.d.ts

@@ -1,16 +1,14 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, Dispose, Reactive } from "./types.js";
+import type { Fn, FnV, FnF, Pred, TPred, Last, Lazy, Dispose, Reactive } from "./types.js";
 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 comp: <Fs extends Fn[]>(...fs: Fs) => (x: Fs[0] extends Fn<infer T> ? T : never) => 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;
 export declare const forEach: <T, R = any>(...fs: Fn<T, R>[]) => (x: T) => void;
-export declare const map: <T, R>(...fs: Fn<T, R>[]) => (x: T) => R[];
 export declare const and: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const or: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const not: <T>(p: Pred<T>) => (x: T) => boolean;
-export declare const comb: <C extends FnV<Fn[]>>(c: C) => (...fs: Fn<FirstParam<FirstParam<C>>, ReturnType<FirstParam<C>>>[]) => (x: FirstParam<FirstParam<C>>) => ReturnType<C>;
 export declare const noop: () => void;
 export declare const identity: <S, T = S>(x: S) => T;
-export declare const constantly: <T>(x: T) => Constantly<T>;
+export declare const constantly: <T>(x: T) => Lazy<T>;
 export declare const apply: <F extends FnV>(f: F) => (x: Parameters<F>) => ReturnType<F>;
 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;
@@ -18,16 +16,14 @@ export declare const lazy: <F extends FnV>(f: F, ...xs: Parameters<F>) => Fn<voi
 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) => 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>, 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: <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[], Maybe<Dispose>>>(f: F) => FnV<Parameters<F>, Dispose>;
-export declare const disposeWith: <T>(f: Fn<T, Dispose>) => (g: Fn<Fn<T>>) => Dispose;
+export declare const swapping: () => <F extends FnV<any[], Dispose | void>>(f: F) => FnV<Parameters<F>, 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 toggler: (f: Fn<void, Dispose>) => Fn<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

@@ -3,11 +3,9 @@ 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);
 export const forEach = (...fs) => (x) => fs.forEach(f => f(x));
-export const map = (...fs) => (x) => fs.map(f => f(x));
 export const and = (...fs) => (x) => fs.reduce((a, f) => a && f(x), true);
 export const or = (...fs) => (x) => fs.reduce((a, f) => a || f(x), false);
 export const not = (p) => (x) => !p(x);
-export const comb = (c) => (...fs) => (x) => c(...fs.map(f => f(x)));
 export const noop = () => { };
 export const identity = (x) => x;
 export const constantly = (x) => () => x;
@@ -22,7 +20,6 @@ export const after = (f) => g => (...xs) => {
     f();
     return r;
 };
-export const mapForEach = (...fs) => comp(map(...fs), apply((forEach)));
 export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
 export const filterT = (p, f) => (x) => { if (p(x))
@@ -43,19 +40,19 @@ export const disposable = (f, disposes = new Set()) => {
     f(bind(add, disposes));
     return () => (disposes.forEach(g => g()), disposes.clear());
 };
-export const disposing = () => {
+export const swapping = () => {
     let dispose = 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) => {
+export const idemp = (d, f) => swapping()((...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));
+    const stop = () => cancel();
+    return (x) => (stop(), (cancel = x ? f() : noop), stop);
 };
 export const voidify = (f) => (...xs) => { f(...xs); };
 export const effectual = (f, g) => disposable(d => d(f(idemp(d, g))));

package/math.d.ts

@@ -32,3 +32,5 @@ 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;
+export declare const divCeil: (a: number, b: number) => number;
+export declare const trunc: (num: number, precision: number) => number;

package/math.js

@@ -41,3 +41,8 @@ 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;
+export const divCeil = (a, b) => Math.ceil(a / b);
+export const trunc = (num, precision) => {
+    const factor = Math.pow(10, precision);
+    return Math.trunc(num * factor) / factor;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.194",
+  "version": "0.0.196",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -9,7 +9,6 @@
     "./checks": "./checks.js",
     "./fn": "./fn.js",
     "./object": "./object.js",
-    "./signal": "./signal.js",
     "./assign": "./assign.js",
     "./map": "./map.js",
     "./set": "./set.js",
@@ -25,6 +24,7 @@
     "./stream": "./stream.js",
     "./progress": "./progress.js",
     "./constants": "./constants.js",
+    "./channel": "./channel.js",
     "./http": "./http.js",
     "./json": "./json.js",
     "./dom": "./dom.js",
@@ -32,7 +32,7 @@
     "./math": "./math.js",
     "./basen": "./basen.js",
     "./struct": "./struct.js",
-    "./buffer": "./buffer.js",
+    "./bytes": "./bytes.js",
     "./base64": "./base64.js",
     "./npy": "./npy.js",
     "./port": "./port.js",
@@ -40,9 +40,6 @@
     "./resource": "./resource.js",
     "./utils": "./utils.js"
   },
-  "devDependencies": {
-    "typescript": "^6.0.2"
-  },
   "publishConfig": {
     "access": "public"
   }

package/resource.d.ts

@@ -1,12 +1,19 @@
-import type { Fn, Dispose, Structure, Reactive } from "./types.js";
+import type { Fn, FnV, Dispose, Structure, Reactive, RecordOf } from "./types.js";
 export type Resource<T> = Reactive<T, Dispose | void> & {
     value: T;
     dispose: Dispose;
     map<S>(f: Fn<T, S>): Resource<S>;
+    flatMap<S>(f: Fn<T, Resource<S>>): Resource<S>;
+    promise(f: Fn<T, Promise<Dispose | void>>): Promise<Dispose>;
 };
 export declare const resource: <T>(value: T, dispose?: Dispose) => Resource<T>;
+export declare const awaited: <T>({ value, dispose }: Resource<Promise<T>>) => Promise<Resource<Awaited<T>>>;
 type Unwrapped<T> = T extends Resource<infer U> ? U : {
     [K in keyof T]: Unwrapped<T[K]>;
 };
 export declare const compose: <R extends Structure<Resource<any>>>(rs: R) => Resource<Unwrapped<R>>;
+export declare const of: <T>(x: T, f: Fn<T, Dispose>) => Resource<T>;
+export declare const gen: <R>(f: FnV<[<T>(r: Resource<T>) => T, Fn<Dispose, Dispose>], R>) => Resource<R>;
+export declare const consume: (f: Fn<(<T>(r: Resource<T>) => T), Dispose | void>) => Dispose;
+export declare const swapping: <F extends RecordOf<FnV<any, Dispose | void>>>(fs: F) => Resource<{ [K in import("./types.js").Entry<keyof F, FnV<Parameters<import("./types.js").ValueOf<F>>, Dispose>> as K[0]]: K[1]; }>;
 export {};