bireactive 0.3.0 → 0.3.2

package/dist/shapes/layout.js

@@ -1,5 +1,5 @@
 // Spatial composition primitives.
-import { Box, boxExpand, reader, transformBox } from "../core/index.js";
+import { Box, boxExpand, derive, reader, transformBox, } from "../core/index.js";
 /** Lay out `shapes` in a row/column. First stays put; the rest bind
  *  their `translate` reactively to sit `gap` past the previous.
  *  Reflows on size or anchor change. */
@@ -72,3 +72,61 @@ export function split(source, axis, parts, opts = {}) {
 export function grid(source, rows, cols, opts = {}) {
     return split(source, "y", rows, opts).map(row => split(row, "x", cols, opts));
 }
+/** Intrinsic ("hug-contents") layout of a tree as nested vertical stacks:
+ *  each container's size is the bottom-up sum of its children, each child is
+ *  placed top-down from its container. Unlike `row`/`col` (which fit items
+ *  into a fixed container), the containers grow to fit. Pure function of the
+ *  inputs, so feeding it a *previewed* tree yields a previewed layout. */
+export function treeStack(opts) {
+    const header = opts.header ?? 0;
+    const pad = opts.pad ?? 0;
+    const gap = opts.gap ?? 0;
+    const minW = opts.minWidth ?? 0;
+    const emptyH = opts.emptyHeight ?? header + 2 * pad;
+    const measure = (id) => {
+        if (!opts.container(id))
+            return opts.leaf(id);
+        const ks = opts.kids(id);
+        if (ks.length === 0)
+            return { w: minW, h: emptyH };
+        let maxw = 0;
+        let h = header + pad;
+        for (const c of ks) {
+            const m = measure(c);
+            maxw = Math.max(maxw, m.w);
+            h += m.h + gap;
+        }
+        return { w: Math.max(minW, maxw + 2 * pad), h: h + pad - gap };
+    };
+    const place = (id, x, y, out) => {
+        const m = measure(id);
+        out.set(id, { x, y, w: m.w, h: m.h });
+        if (opts.container(id)) {
+            let cy = y + header + pad;
+            for (const c of opts.kids(id)) {
+                place(c, x + pad, cy, out);
+                cy += measure(c).h + gap;
+            }
+        }
+    };
+    const boxes = derive(() => {
+        const out = new Map();
+        for (const r of opts.roots()) {
+            const o = opts.origin(r);
+            place(r, o.x, o.y, out);
+        }
+        return out;
+    });
+    const cache = new Map();
+    return {
+        boxes,
+        box(id) {
+            let b = cache.get(id);
+            if (!b) {
+                b = Box.derive(() => boxes.value.get(id) ?? { x: 0, y: 0, w: 0, h: 0 });
+                cache.set(id, b);
+            }
+            return b;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bireactive",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Bi-directional reactive programming.",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,6 +11,18 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./automerge": {
+      "types": "./dist/automerge/index.d.ts",
+      "import": "./dist/automerge/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-dev-runtime.d.ts",
+      "import": "./dist/jsx-dev-runtime.js"
+    },
     "./package.json": "./package.json"
   },
   "sideEffects": false,
@@ -22,6 +34,9 @@
   "scripts": {
     "dev": "vite --host",
     "site": "vite build && typedoc",
+    "docs": "typedoc",
+    "docs:dev": "typedoc --watch",
+    "docs:preview": "python3 -m http.server 5556 --directory dist-web/api",
     "preview": "vite preview",
     "prebuild": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json --resolve-full-paths",
@@ -38,6 +53,9 @@
     "postversion": "npm publish && git push --follow-tags"
   },
   "dependencies": {
+    "@automerge/automerge-repo": "^2.6.0-subduction.34",
+    "@automerge/automerge-repo-network-broadcastchannel": "^2.6.0-subduction.34",
+    "@automerge/automerge-repo-storage-indexeddb": "^2.6.0-subduction.34",
     "prism-esm": "^1.29.0-fix.6",
     "temml": "^0.13.3"
   },
@@ -45,6 +63,7 @@
     "@biomejs/biome": "2.4.15",
     "@preact/signals-core": "^1.14.2",
     "@types/node": "^22.0.0",
+    "@typhonjs-typedoc/typedoc-theme-dmt": "^0.4.0",
     "alien-signals": "^3.2.1",
     "fast-check": "^4.8.0",
     "gray-matter": "^4.0.3",
@@ -57,6 +76,8 @@
     "typescript": "^6.0.3",
     "vite": "^7.3.3",
     "vite-node": "^5.3.0",
+    "vite-plugin-top-level-await": "^1.6.0",
+    "vite-plugin-wasm": "^3.6.0",
     "vitest": "^4.1.7"
   },
   "keywords": [

package/dist/coll.d.ts

@@ -1,74 +0,0 @@
-import { type Cell, type Read, type Writable } from "./core/index.js";
-/** Accessor for an element's writable field cell. Forward reads `.value`;
- *  the backward pass writes it. */
-export type Accessor<E, V> = (e: E) => Writable<Cell<V>>;
-/** A forward test over an element's fields, optionally assertable —
- *  `assert(e)` makes the test pass by writing fields. */
-export interface FieldPred<E> {
-    (e: E): boolean;
-    assert?: (e: E) => void;
-}
-export interface Group<K, E> {
-    key: K;
-    items: readonly E[];
-}
-export interface GroupOpts<E, K> {
-    /** Fixed key order; seeds empty buckets and pins column order. */
-    order?: readonly K[];
-    /** Order field within each group; enables `move(e, key, index)`. */
-    sort?: Accessor<E, number>;
-}
-/** `field === value`, assertable by writing the field. */
-export declare function is<E, V>(field: Accessor<E, V>, value: V): FieldPred<E>;
-/** Conjunction; asserts every clause. */
-export declare function allPass<E>(...preds: readonly FieldPred<E>[]): FieldPred<E>;
-/** Read-only projection with chainable structural lenses. */
-export declare class View<E> {
-    protected readonly list: Read<readonly E[]>;
-    readonly key: (e: E) => unknown;
-    protected readonly parent: View<E> | null;
-    protected constructor(list: Read<readonly E[]>, key: (e: E) => unknown, parent: View<E> | null);
-    /** Current members; tracked when read in an effect/derive. */
-    get items(): readonly E[];
-    /** The source collection at the head of the chain. */
-    get root(): Coll<E>;
-    /** Make `e` appear in this view: satisfy own constraint, recursively up. */
-    assertContains(e: E): void;
-    protected assertSelf(_e: E): void;
-    filter(pred: FieldPred<E>): View<E>;
-    sortBy(field: Accessor<E, number>): SortView<E>;
-    groupBy<K>(field: Accessor<E, K>, opts?: GroupOpts<E, K>): GroupView<K, E>;
-    map<F>(f: (e: E) => F): Read<readonly F[]>;
-    /** Remove `e` from the source. */
-    remove(e: E): void;
-}
-/** A writable source collection. */
-export declare class Coll<E> extends View<E> {
-    #private;
-    constructor(items: readonly E[], key: (e: E) => unknown);
-    assertContains(e: E): void;
-    insert(e: E, at?: number): void;
-    removeFromSource(e: E): void;
-}
-/** Sorted view. `move` writes the order field between the drop neighbours. */
-export declare class SortView<E> extends View<E> {
-    #private;
-    constructor(parent: View<E>, field: Accessor<E, number>);
-    move(e: E, to: number): void;
-}
-/** Grouped view. `move`/`insert` write the group field (and, with a `sort`
- *  field, the order field). Backward composition runs the parent chain. */
-export declare class GroupView<K, E> {
-    #private;
-    readonly groups: Read<readonly Group<K, E>[]>;
-    constructor(parent: View<E>, field: Accessor<E, K>, opts?: GroupOpts<E, K>);
-    get value(): readonly Group<K, E>[];
-    map<F>(f: (g: Group<K, E>) => F): Read<readonly F[]>;
-    /** Place `e` in group `toKey` at `index`. Inserts it into the source if
-     *  it isn't there yet, asserts every upstream filter, then writes the
-     *  group key and order field — all in one batch. */
-    move(e: E, toKey: K, index?: number): void;
-    insert(e: E, toKey: K, index?: number): void;
-    remove(e: E): void;
-}
-export declare function coll<E>(items: readonly E[], key: (e: E) => unknown): Coll<E>;

package/dist/coll.js

@@ -1,210 +0,0 @@
-// coll.ts — a keyed, ordered, *bidirectional* collection.
-//
-// The structural sibling of `tree.ts`. A `Coll<E>` holds stable element
-// handles (records of cells), and each projection — `filter` / `sortBy` /
-// `groupBy` — is a WRITABLE structural lens. You edit the *view* and the
-// backward pass writes the elements' own fields:
-//
-//   sortBy(rank)  → move(e, i)        writes `rank`   (position is a field)
-//   groupBy(key)  → move(e, k, i)     writes `key`    (membership is a field)
-//   filter(pred)  → insert/assert     writes whatever pred demands
-//
-// Because position / group / visibility are the elements' own writable
-// cells, these lenses are COMPLEMENT-FREE — the "complement" lives in the
-// field cells, not the lens (contrast `Seq<T>`, where order is imposed and
-// must be remembered). One `move`/`insert` composes the backward passes up
-// the chain in a single `batch`: drop into a filtered + grouped + sorted
-// view and the filter's predicate, the group key, and the rank all get set
-// at once.
-//
-// Two change classes, mirroring the engine's two levels:
-//   • value change   — a field cell changes; forward derivations re-flow.
-//   • structural edit — insert/remove/move; a discrete batched transition.
-// No lens edges are built at runtime, so acyclicity holds as ever.
-import { batch, cell, derive } from "./core/index.js";
-/** `field === value`, assertable by writing the field. */
-export function is(field, value) {
-    const p = ((e) => field(e).value === value);
-    p.assert = (e) => {
-        field(e).value = value;
-    };
-    return p;
-}
-/** Conjunction; asserts every clause. */
-export function allPass(...preds) {
-    const p = ((e) => preds.every(q => q(e)));
-    p.assert = (e) => {
-        for (const q of preds)
-            q.assert?.(e);
-    };
-    return p;
-}
-/** Read-only projection with chainable structural lenses. */
-export class View {
-    list;
-    key;
-    parent;
-    constructor(list, key, parent) {
-        this.list = list;
-        this.key = key;
-        this.parent = parent;
-    }
-    /** Current members; tracked when read in an effect/derive. */
-    get items() {
-        return this.list.value;
-    }
-    /** The source collection at the head of the chain. */
-    get root() {
-        let v = this;
-        while (v.parent)
-            v = v.parent;
-        return v;
-    }
-    /** Make `e` appear in this view: satisfy own constraint, recursively up. */
-    assertContains(e) {
-        this.parent?.assertContains(e);
-        this.assertSelf(e);
-    }
-    assertSelf(_e) { }
-    filter(pred) {
-        return new FilterView(this, pred);
-    }
-    sortBy(field) {
-        return new SortView(this, field);
-    }
-    groupBy(field, opts) {
-        return new GroupView(this, field, opts);
-    }
-    map(f) {
-        return derive(() => this.list.value.map(f));
-    }
-    /** Remove `e` from the source. */
-    remove(e) {
-        this.root.removeFromSource(e);
-    }
-}
-/** A writable source collection. */
-export class Coll extends View {
-    #src;
-    constructor(items, key) {
-        const src = cell(items);
-        super(src, key, null);
-        this.#src = src;
-    }
-    assertContains(e) {
-        if (!this.#src.value.includes(e))
-            this.insert(e);
-    }
-    insert(e, at) {
-        const arr = [...this.#src.value];
-        if (at == null)
-            arr.push(e);
-        else
-            arr.splice(at, 0, e);
-        this.#src.value = arr;
-    }
-    removeFromSource(e) {
-        this.#src.value = this.#src.value.filter(x => x !== e);
-    }
-}
-class FilterView extends View {
-    #pred;
-    constructor(parent, pred) {
-        super(derive(() => parent.items.filter(pred)), parent.key, parent);
-        this.#pred = pred;
-    }
-    assertSelf(e) {
-        this.#pred.assert?.(e);
-    }
-}
-/** Sorted view. `move` writes the order field between the drop neighbours. */
-export class SortView extends View {
-    #field;
-    constructor(parent, field) {
-        super(derive(() => [...parent.items].sort((a, b) => field(a).value - field(b).value)), parent.key, parent);
-        this.#field = field;
-    }
-    move(e, to) {
-        const others = this.items.filter(x => x !== e);
-        batch(() => {
-            this.assertContains(e);
-            this.#field(e).value = between(rankAt(others, this.#field, to - 1), rankAt(others, this.#field, to));
-        });
-    }
-}
-/** Grouped view. `move`/`insert` write the group field (and, with a `sort`
- *  field, the order field). Backward composition runs the parent chain. */
-export class GroupView {
-    groups;
-    #parent;
-    #field;
-    #order;
-    #sort;
-    constructor(parent, field, opts = {}) {
-        this.#parent = parent;
-        this.#field = field;
-        this.#order = opts.order ?? [];
-        this.#sort = opts.sort;
-        this.groups = derive(() => {
-            const sort = this.#sort;
-            const items = sort
-                ? [...parent.items].sort((a, b) => sort(a).value - sort(b).value)
-                : parent.items;
-            return groupItems(items, e => field(e).value, this.#order);
-        });
-    }
-    get value() {
-        return this.groups.value;
-    }
-    map(f) {
-        return derive(() => this.value.map(f));
-    }
-    /** Place `e` in group `toKey` at `index`. Inserts it into the source if
-     *  it isn't there yet, asserts every upstream filter, then writes the
-     *  group key and order field — all in one batch. */
-    move(e, toKey, index) {
-        const target = (this.value.find(g => Object.is(g.key, toKey))?.items ?? []).filter(x => x !== e);
-        const sort = this.#sort;
-        batch(() => {
-            this.#parent.assertContains(e);
-            this.#field(e).value = toKey;
-            if (sort && index != null)
-                sort(e).value = between(rankAt(target, sort, index - 1), rankAt(target, sort, index));
-        });
-    }
-    insert(e, toKey, index) {
-        this.move(e, toKey, index);
-    }
-    remove(e) {
-        this.#parent.remove(e);
-    }
-}
-function groupItems(items, keyOf, order) {
-    const buckets = new Map();
-    for (const k of order)
-        buckets.set(k, []);
-    for (const e of items) {
-        const k = keyOf(e);
-        const arr = buckets.get(k);
-        if (arr)
-            arr.push(e);
-        else
-            buckets.set(k, [e]);
-    }
-    return [...buckets].map(([key, items]) => ({ key, items }));
-}
-function rankAt(arr, field, i) {
-    return i >= 0 && i < arr.length ? field(arr[i]).value : undefined;
-}
-function between(a, b) {
-    if (a != null && b != null)
-        return (a + b) / 2;
-    if (a != null)
-        return a + 1;
-    if (b != null)
-        return b - 1;
-    return 0;
-}
-export function coll(items, key) {
-    return new Coll(items, key);
-}

package/dist/core/lenses/closed-form-policies.d.ts

@@ -1,57 +0,0 @@
-import { type Cell, Num, type Read, type Traits, Vec, type Writable } from "../index.js";
-type V = {
-    x: number;
-    y: number;
-};
-/** Writable centroid; on write, translates every point by the delta.
- *  The Vec-specific group-action reading of `mean`. */
-export declare function rigidTranslate(points: readonly Writable<Vec>[]): Writable<Vec>;
-/** Writable angle from `pivot` to `points[0]`; write rotates every input
- *  about `pivot` by (target − current) via its `Pivotal` trait.
- *
- *  Trait-generic: Vec rotates position; Pose rotates position AND
- *  orientation. Rotation-about-pivot fixes the pivot and preserves radial
- *  distances, so scale-about-pivot reads unchanged. `pivot` is reactive
- *  (re-read per write); pass `rigidTranslate(points)` for rotation about
- *  the cluster's own centroid. */
-export declare function rotateAbout<T extends {
-    x: number;
-    y: number;
-}>(points: readonly Writable<Traits<T, "pivotal"> & Cell<T>>[], pivot: Read<V>): Writable<Num>;
-/** Writable radial distance from pivot to `points[0]`; write scales every
- *  input radially about `pivot` (negative target reflects). Exact
- *  cross-channel invariance with `rotateAbout`.
- *
- *  Complement carries per-point offsets from the pivot at the last
- *  non-degenerate state, so a collapse onto the pivot (radius ≈ 0)
- *  reinflates from the stored shape. Pose `theta` survives the round-trip
- *  (only spatial offset is stored). */
-export declare function scaleAbout<T extends {
-    x: number;
-    y: number;
-}>(points: readonly Writable<Traits<T, "pivotal"> & Cell<T>>[], pivot: Read<V>): Writable<Num>;
-/** Per-axis scale about a pivot. Vec-specific (Pivotal has no per-axis
- *  method yet). Complement carries per-point per-axis fractions of
- *  point 0's offset, so a per-axis collapse is recoverable (cf.
- *  `bboxLens.size`). */
-export declare function scaleAboutXY(points: readonly Writable<Vec>[], pivot: Read<V>): Writable<Vec>;
-export declare function bestFitLine(points: readonly Writable<Vec>[]): {
-    point: Writable<Vec>;
-    direction: Writable<Num>;
-};
-export declare function bestFitCircle(points: readonly Writable<Vec>[]): {
-    center: Writable<Vec>;
-    radius: Writable<Num>;
-};
-export declare function pca(points: readonly Writable<Vec>[]): {
-    mean: Writable<Vec>;
-    rotation: Writable<Num>;
-    majorLength: Writable<Num>;
-    minorLength: Writable<Num>;
-};
-/** Writable total over K parts; write scales all parts proportionally,
- *  preserving their ratios. A `remember` anchored at zero with a signed
- *  sum feature: a collapse to zero reinflates the stored ratios, seeded
- *  uniform so an all-zero start splits evenly. */
-export declare function total(parts: readonly Writable<Num>[]): Writable<Num>;
-export {};

package/dist/core/lenses/decompositions.d.ts

@@ -1,14 +0,0 @@
-import { Num, Vec, type Writable } from "../index.js";
-export declare function meanDiff(a: Num, b: Num): {
-    mean: Writable<Num>;
-    diff: Writable<Num>;
-};
-export declare function procrustes(points: readonly Writable<Vec>[]): {
-    centroid: Writable<Vec>;
-    rotation: Writable<Num>;
-    scale: Writable<Num>;
-};
-export declare function bbox(points: readonly Writable<Vec>[]): {
-    center: Writable<Vec>;
-    size: Writable<Vec>;
-};