@cgtk/std 0.0.192 → 0.0.194

package/array.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Tuple } from "./types";
+import type { Fn, Tuple } from "./types.js";
 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[];

package/array.js

@@ -1,4 +1,4 @@
-import { comp, scan } from "./fn";
+import { comp, scan } from "./fn.js";
 export const empty = () => [];
 export const push = (xs, x) => (xs.push(x), xs);
 export const unshift = (xs, x) => (xs.unshift(x), xs);

package/assign.d.ts

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

package/async.d.ts

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

package/async.js

@@ -1,18 +1,19 @@
-import { filterT, disposable } from "./fn";
-import { isDefined } from "./checks";
+import { filterT, disposable } from "./fn.js";
+import { isDefined } from "./checks.js";
 export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
         reject(signal.reason);
     else {
-        setTimeout(() => {
+        const t = setTimeout(() => {
             if (signal?.aborted)
                 reject(signal.reason);
             else
                 resolve(undefined);
         }, ms);
+        signal?.addEventListener("abort", () => (clearTimeout(t), reject(signal.reason)), { once: true });
     }
 });
-export const delay = (ms) => async (x) => (await timeout(ms), x);
+export const delay = (ms, signal) => async (x) => (await timeout(ms, signal), x);
 export const probing = (p) => {
     let value = undefined;
     p.then(x => value = x);

package/basen.js

@@ -1,4 +1,4 @@
-import { toFixedMax } from "./number";
+import { toFixedMax } from "./number.js";
 export const basen = (b) => (m = 0, n = 0) => [b, m, n];
 export const base10 = basen(10);
 export const normalize = (x) => {

package/buffer.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "./types";
+import type { Fn } from "./types.js";
 export interface BufReader {
     offset: number;
     line: Fn<void, string>;

package/buffer.js

@@ -1,4 +1,4 @@
-import { readLine } from './string';
+import { readLine } from './string.js';
 export const bufReader = (data, offset = 0) => {
     const rl = readLine();
     const dv = new DataView(data.buffer, data.byteOffset);

package/checks.d.ts

@@ -1,10 +1,10 @@
-import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Optional } from "./types";
+import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from "./types.js";
 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 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;
+export declare const isDefined: <T>(x: Maybe<T>) => x is T;
 export declare function assert(condition: boolean, msg: string): asserts condition;
 export declare function assertType<T>(x: any, pred: TPred<T>, msg: string): asserts x is T;
 export declare const isObject: TPred<Object>;

package/checks.js

@@ -1,5 +1,5 @@
-import { comp, not, apply, and } from "./fn";
-import { retain } from "./array";
+import { comp, not, apply, and } from "./fn.js";
+import { retain } 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 ||

package/dom.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Dispose, RecordOf, Optional } from "./types";
+import type { Fn, 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: {
@@ -46,5 +46,5 @@ export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, optio
 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 declare const qs: (search?: string) => Maybe<RecordOf<string>>;
 export {};

package/dom.js

@@ -1,6 +1,6 @@
-import { forEach, noop } from "./fn";
-import { isDefined } from "./checks";
-import { EMPTY } from "./constants";
+import { forEach, noop } from "./fn.js";
+import { isDefined } 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);

package/fn.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Optional, Dispose, Reactive } from "./types";
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, 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 pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
@@ -23,9 +23,9 @@ 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 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 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 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;

package/fn.js

@@ -1,4 +1,4 @@
-import { add } from "./set";
+import { add } from "./set.js";
 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);
@@ -34,10 +34,10 @@ export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs)
         cache.set(k, f(...xs));
     return cache.get(k);
 };
-export const abortable = (f, reason) => {
+export const abortable = (f) => {
     const ctrl = new AbortController();
     f(ctrl.signal);
-    return () => ctrl.abort(reason);
+    return (reason) => ctrl.abort(reason);
 };
 export const disposable = (f, disposes = new Set()) => {
     f(bind(add, disposes));

package/http.d.ts

@@ -1,10 +1,9 @@
 export declare const assertStatus: (status: number) => (resp: Response) => void;
 export declare const contentLength: (response: Response) => number;
-export declare const toByteArray: (stream: ReadableStream<Uint8Array>) => Promise<Uint8Array<ArrayBufferLike>>;
-export declare const fetchBuffer: (url: string | URL | Request, init?: RequestInit) => Promise<Uint8Array<ArrayBufferLike>>;
-export declare const fetchText: (url: string, init?: RequestInit) => Promise<string>;
-export declare const fetchDOM: (url: string, init?: RequestInit) => Promise<HTMLElement>;
+export declare const fetchBuffer: (url: string | URL | Request, init?: RequestInit) => Promise<ArrayBuffer>;
+export declare const fetchText: (url: string | URL | Request, init?: RequestInit) => Promise<string>;
+export declare const fetchDOM: (url: string | URL | Request, 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>;
+export declare const fetchImageBitmap: (url: string | URL | Request, init?: RequestInit) => Promise<ImageBitmap>;
+export declare const fetchJSON: (url: string | URL | Request, init?: RequestInit) => Promise<any>;
+export declare const fetchDataUrl: (url: string | URL | Request, init?: RequestInit) => Promise<string>;

package/http.js

@@ -1,18 +1,14 @@
-import { tee } from "./fn";
-import { assert } from "./checks";
-import { reduceArray } from './stream';
-import { concat } from "./typedarray";
-import { fromBytes } from "./json";
+import { tee } from "./fn.js";
+import { assert } from "./checks.js";
 export const assertStatus = (status) => (resp) => assert(resp.status == status, `Invalid HTTP Status ${resp.status}: ${resp.url}`);
 export const contentLength = (response) => {
     const cl = response.headers.get("content-length");
     return cl ? parseInt(cl) : -1;
 };
-export const toByteArray = async (stream) => concat(await reduceArray(stream));
 export const fetchBuffer = (url, init) => fetch(url, init)
     .then(tee(assertStatus(200)))
-    .then(resp => resp.body)
-    .then(toByteArray);
+    .then(resp => resp.blob())
+    .then(blob => blob.arrayBuffer());
 export const fetchText = (url, init) => fetchBuffer(url, init).then(buf => new TextDecoder("utf-8").decode(buf));
 export const fetchDOM = (url, init) => fetchText(url, init).then(txt => new DOMParser().parseFromString(txt, "image/svg+xml").documentElement);
 export const fetchImage = (src) => new Promise((resolve, reject) => {
@@ -22,13 +18,13 @@ 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)
+export const fetchImageBitmap = async (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
+    .then(resp => resp.blob())
+    .then(blob => createImageBitmap(blob, { colorSpaceConversion: "none" }));
+export const fetchJSON = (url, init) => fetchText(url, init).then(JSON.parse);
+export const fetchDataUrl = (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
     .then(resp => resp.blob())
     .then(blob => new Promise(resolve => {
     const f = new FileReader();

package/iterable.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, Indexed, Pred } from "./types";
+import type { Fn, FnV, Indexed, Pred } from "./types.js";
 export declare const next: <T>(xs: Iterator<T>) => T;
 export declare const repeat: (n: number) => <A>(x: A) => Iterator<A>;
 export declare const just: <T>(x: T) => IteratorObject<T>;

package/iterable.js

@@ -1,6 +1,6 @@
-import { assert, isDefined } from "./checks";
-import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn";
-import { set } from "./map";
+import { assert, isDefined } from "./checks.js";
+import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
+import { set } from "./map.js";
 export const next = (xs) => {
     const { done, value } = xs.next();
     assert(isDefined(done) && !done, "iterator done");

package/json.d.ts

@@ -1 +1 @@
-export declare const fromBytes: (data: Uint8Array) => any;
+export declare const fromBytes: (data: AllowSharedBufferSource, options?: TextDecodeOptions) => any;

package/json.js

@@ -1 +1 @@
-export const fromBytes = (data) => JSON.parse(new TextDecoder("utf-8").decode(data));
+export const fromBytes = (data, options) => JSON.parse(new TextDecoder("utf-8").decode(data, options));

package/map.d.ts

@@ -1,4 +1,4 @@
-import type { FnV, Optional } from "./types";
+import type { FnV, Maybe } from "./types.js";
 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>;
@@ -7,6 +7,6 @@ export declare const transform: <K, S, V>({ create, update, remove }: {
 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>;
-export declare const first: <K, V>(m: Map<K, V>) => Optional<V>;
-export declare const shift: <K, V>(m: Map<K, V>) => Optional<[K, V]>;
+export declare const first: <K, V>(m: Map<K, V>) => Maybe<V>;
+export declare const shift: <K, V>(m: Map<K, V>) => Maybe<[K, V]>;
 export declare const reduce: <K, V, T>(m: Map<K, V>, f: FnV<[T, V, K, Map<K, V>], T>, a: T) => T;

package/map.js

@@ -1,5 +1,5 @@
-import { isDefined } from "./checks";
-import * as I from "./iterable";
+import { isDefined } from "./checks.js";
+import * as I from "./iterable.js";
 export const transform = ({ create, update, remove }, dst = new Map()) => (src) => {
     for (const k of dst.keys())
         if (!src.has(k)) {

package/math.js

@@ -1,4 +1,4 @@
-import { isclose } from "./checks";
+import { isclose } from "./checks.js";
 export const PI = Math.PI;
 export const TAU = PI * 2;
 export const HALF_PI = PI / 2;

package/npy.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray, Elements } from "./types";
+import type { TypedArray, Elements } from "./types.js";
 declare const DTYPES: readonly ["|u1", "<u2", "<u4", "|i1", "<i2", "<i4", "<f4", "<f8"];
 type DType = Elements<typeof DTYPES>;
 export interface NDArray {

package/number.js

@@ -1,4 +1,4 @@
-import { isBigInt } from "./checks";
+import { isBigInt } from "./checks.js";
 export const add = (a, x) => a + x;
 export const toFixed = (x, n = 0) => isBigInt(x) ? x : x.toFixed(n);
 export const toFixedMax = (x, n = 0) => {

package/object.d.ts

@@ -1,4 +1,4 @@
-import type { RecordOf, Elements, Optional, FnV, ValueOf, EntriesTuple, UnionToTuple, Entry } from "./types.js";
+import type { RecordOf, Elements, Maybe, 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>;
@@ -11,5 +11,5 @@ export declare const assoc: <T extends RecordOf<any>>(a: T, [k, v]: [keyof T, Va
 type Merge<T extends RecordOf<unknown>, S extends RecordOf<unknown>, V> = {
     [K in keyof (T & S)]: V;
 };
-export declare const merge: <T, S = T, V = T>(f: FnV<[Optional<T>, Optional<S>], V>) => <X extends RecordOf<T>, Y extends RecordOf<T>>(x: X, y: Y) => Merge<X, Y, V>;
+export declare const merge: <T, S = T, V = T>(f: FnV<[Maybe<T>, Maybe<S>], V>) => <X extends RecordOf<T>, Y extends RecordOf<T>>(x: X, y: Y) => Merge<X, Y, V>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.192",
+  "version": "0.0.194",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -41,7 +41,7 @@
     "./utils": "./utils.js"
   },
   "devDependencies": {
-    "typescript": "^5.9.2"
+    "typescript": "^6.0.2"
   },
   "publishConfig": {
     "access": "public"

package/port.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise } from "./types";
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types.js";
 export interface Message<K, V> {
     type: K;
     payload: V;
@@ -8,6 +8,7 @@ export type Port = {
 };
 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 messageSources: <T extends RecordOf<any>, S = Worker>(worker: MessageEventTarget<S>) => { [K in keyof T]: Reactive<T[K]>; };
 export declare const postMessages: <T extends RecordOf<any>>(port: Port) => { [k in keyof T]: FnV<[T[k], (StructuredSerializeOptions | undefined)?]>; };
 export interface Request {
     id: number;

package/port.js

@@ -1,10 +1,13 @@
-import { forEach, noop } from "./fn";
-import { isDefined } from "./checks";
-import { on } from "./dom";
-import { promise } from "./async";
+import { forEach, noop, bind } from "./fn.js";
+import { isDefined } from "./checks.js";
+import { on } from "./dom.js";
+import { promise } from "./async.js";
 ;
 export const onMessages = (target, fs) => on(target, "message", ({ data: { type, payload } }) => (type in fs) && fs[type](payload));
 export const onMessage = (target, name, f) => on(target, "message", ({ data: { type, payload } }) => type == name && f(payload));
+export const messageSources = (worker) => new Proxy({}, {
+    get: (_, k) => bind((onMessage), worker, k)
+});
 export const postMessages = (port) => new Proxy({}, {
     get: (_, type) => (payload, options) => port.postMessage({ type, payload }, options)
 });

package/progress.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from './types';
+import type { Fn } from './types.js';
 export type Progress = {
     begin: Fn<void>;
     progress: Fn<number>;

package/rect.d.ts

@@ -1,4 +1,4 @@
-import type { Tuple } from "./types";
+import type { Tuple } from "./types.js";
 export type Rect = Tuple<number, 4>;
 export declare const rect: (x: number, y: number, w: number, h: number) => Rect;
 export declare const vertical: (ratio: number[]) => (i: number) => ([x, _, w, h]: Rect) => Rect;

package/rect.js

@@ -1,4 +1,4 @@
-import { add } from "./number";
+import { add } from "./number.js";
 export const rect = (x, y, w, h) => [x, y, w, h];
 export const vertical = (ratio) => {
     const tot = ratio.reduce(add, 0);

package/resource.d.ts

@@ -1,10 +1,12 @@
-import type { Fn, Dispose, Resource, RecordOf } from "./types";
-export declare const resource: <T>(x: T, d?: Dispose) => Resource<T>;
-export declare const map: <T, S>(r: Resource<T>, g: Fn<T, S>) => Resource<S>;
-export declare const flatMap: <T, S>(r: Resource<T>, g: Fn<T, Resource<S>>) => Resource<S>;
-type Structure<T> = T | Structure<T>[] | RecordOf<Structure<T>>;
-type Resolved<T extends Structure<Resource<any>>> = {
-    [K in keyof T]: T[K] extends Resource<infer R> ? R : T[K] extends Structure<Resource<any>> ? Resolved<T[K]> : never;
+import type { Fn, Dispose, Structure, Reactive } from "./types.js";
+export type Resource<T> = Reactive<T, Dispose | void> & {
+    value: T;
+    dispose: Dispose;
+    map<S>(f: Fn<T, S>): Resource<S>;
 };
-export declare const combine: <R extends Structure<Resource<any>>>(rs: R) => Resource<Resolved<R>>;
+export declare const resource: <T>(value: T, dispose?: Dispose) => Resource<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 {};

package/resource.js

@@ -1,21 +1,28 @@
-import { forEach, noop, comp } from "./fn";
-import { push, empty } from "./array";
-import { assoc } from "./object";
-import { reduceRec } from './iterable';
-import { isFunction } from "./checks";
-export const resource = (x, d = noop) => (f) => forEach(f(x) ?? noop, d);
-export const map = (r, g) => f => r(comp(g, f));
-export const flatMap = (r, g) => f => r(x => g(x)(f));
-const isResource = (r) => isFunction(r);
-export const combine = (rs) => f => {
-    const rec = (rs, f) => {
+import { forEach, noop } from "./fn.js";
+import { isFunction } from "./checks.js";
+export const resource = (value, dispose = noop) => {
+    const res = ((f) => forEach(f(value) ?? noop, dispose));
+    res.value = value;
+    res.dispose = dispose;
+    res.map = (f) => resource(f(value), dispose);
+    return res;
+};
+const isResource = (r) => isFunction(r)
+    && Object.hasOwn(r, "value")
+    && Object.hasOwn(r, "dispose")
+    && isFunction(r["dispose"]);
+export const compose = (rs) => {
+    const disposes = [];
+    const rec = (rs) => {
         if (isResource(rs)) {
-            return rs(x => f(x) ?? noop);
+            disposes.push(rs.dispose);
+            return rs.value;
         }
         else if (Array.isArray(rs)) {
-            return reduceRec(Iterator.from(rs), (o, r, next) => rec(r, (x) => next(push(o, x))), empty(), o => f(o) ?? noop);
+            return rs.map(rec);
         }
-        return reduceRec(Iterator.from(Object.entries(rs)), (o, [k, r], next) => rec(r, (x) => next(assoc(o, [k, x]))), {}, r => f(r) ?? noop);
+        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
     };
-    return rec(rs, f);
+    const value = rec(rs);
+    return resource(value, forEach(...disposes));
 };

package/schedule.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, FnV, Reactive } from './types';
+import type { Dispose, Fn, FnV, Reactive } from './types.js';
 export declare const raf: Reactive<number>;
 export declare const timeout: (ms: number) => Reactive<void>;
 export declare const schedule: <T>(s: Reactive<T>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;

package/schedule.js

@@ -1,5 +1,5 @@
-import { isUndefined, isDefined, counted } from './checks';
-import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn';
+import { isUndefined, isDefined, counted } from './checks.js';
+import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn.js';
 export const raf = f => bind(cancelAnimationFrame, requestAnimationFrame(f));
 export const timeout = (ms) => f => bind(clearTimeout, setTimeout(f, ms));
 export const schedule = (s) => (f) => call(comp(apply(bind((lazy), f)), s));

package/set.d.ts

@@ -1 +1,2 @@
 export declare const add: <T>(xs: Set<T>, x: T) => () => boolean;
+export declare const isEqual: <T>(a: Set<T>, b: Set<T>) => boolean;

package/set.js

@@ -1 +1,2 @@
 export const add = (xs, x) => (xs.add(x), () => xs.delete(x));
+export const isEqual = (a, b) => a.size == b.size && a.isSubsetOf(b) && b.isSubsetOf(a);

package/signal.d.ts

@@ -1,24 +1,37 @@
-import type { Fn, FnV, Fns, Reactive, RecordOf } from "./types";
+import type { Fn, FnV, Fns, Pred, Reactive, RecordOf, Structure } from "./types.js";
 export type Signal<T> = Fn<T> & {
     on: Reactive<T>;
 };
 export declare const create: <T>(f: Fn<T>, on: Reactive<T>) => Signal<T>;
 export declare const signal: <T>(fns?: Set<Fn<T>>) => Signal<T>;
-export interface Value<T> {
+export declare const map: <T, S>(source: Reactive<T>, f: Fn<T, S>) => Reactive<S>;
+export declare const filter: <T>(source: Reactive<T>, p: Pred<T>) => Reactive<T>;
+export declare const cache: <T>(source: Reactive<T>) => Reactive<T>;
+export interface ValueLike<T> {
     value: T;
     on: Reactive<T>;
+}
+export interface Box<T, F extends RecordOf<FnV>> extends ValueLike<T> {
+    ops: F;
+}
+export interface Value<T> extends ValueLike<T> {
     op: <F extends FnV>(f: Fn<T, F>) => F;
     ops: <F extends RecordOf<FnV>>(f: Fn<T, F>) => F;
     set: Fn<T>;
     update(): void;
+    map<S>(f: Fn<T, S>): Reactive<S>;
+    box: <F extends RecordOf<FnV>>(f: Fn<T, F>) => Box<T, F>;
 }
-export declare const value: <T>(x: T) => Value<T>;
+export declare const value: <T>(x: T, fs?: Set<Fn<T>>) => Value<T>;
 export type Values<T extends RecordOf<any>> = {
     [k in keyof T]: Value<T[k]>;
 };
 export declare const values: <T extends RecordOf<any>>(vals: T) => Values<T>;
-export declare const map: <T, S>(source: Reactive<T>, f: Fn<T, S>) => Reactive<S>;
-export declare const merge: <T extends RecordOf<any>>(vals: Values<T>) => Reactive<T>;
+type Unwrapped<T> = T extends ValueLike<infer U> ? U : {
+    [K in keyof T]: Unwrapped<T[K]>;
+};
+export declare const compose: <T extends Structure<ValueLike<any>>, S = Unwrapped<T>>(xs: T, transform?: Fn<Unwrapped<T>, S>) => Reactive<S>;
 export declare const mux: <I extends RecordOf<any>, O extends RecordOf<any>>(init: Fn<Fns<O>, Fns<I>>) => Fns<I> & {
     on: { [k in keyof O]: Reactive<O[k]>; };
 };
+export {};