bireactive 0.2.4 → 0.3.1

package/dist/propagators/flex.js

@@ -0,0 +1,189 @@
+// flex.ts — flexbox as interval propagation.
+//
+// A flex line is two phases, both grounded in the interval lattice:
+//
+//   1. FEASIBILITY (narrowing). Given the container's content size and
+//      each item's [min, max], the `total` relation narrows every item
+//      to the band it could occupy: `wᵢ ∈ content − Σ(others)`. If any
+//      band comes back empty the line can't fit — that's a real lattice
+//      contradiction, reported, not a silent overflow.
+//
+//   2. RESOLUTION (point pick). Within the feasible bands, grow/shrink
+//      weights distribute the slack to a single size per item. This is
+//      the one place a *preference* (not a constraint) enters, so it's
+//      kept out of the narrowing.
+//
+// The line operates on plain `Box` cells — zero ceremony, nothing is
+// coloured. Nesting composes through the ordinary reactive graph: a
+// child container is just an item of its parent, so resizing the root
+// re-runs each line top-down. `row`/`col` are the only public surface;
+// everything else is the two phases above.
+import { isCell, readNow, } from "../core/index.js";
+import { interval } from "./lattice.js";
+import { propagator } from "./solver.js";
+const asW = (n) => n;
+function readDeps(...vs) {
+    return vs.filter(isCell);
+}
+const clamp = (v, lo, hi) => Math.min(Math.max(v, lo), hi);
+function specs(items) {
+    return items.map(it => "box" in it
+        ? {
+            box: it.box,
+            grow: it.grow ?? 1,
+            shrink: it.shrink ?? 1,
+            min: it.min ?? 0,
+            max: it.max ?? Number.POSITIVE_INFINITY,
+            basis: it.basis,
+        }
+        : { box: it, grow: 1, shrink: 1, min: 0, max: Number.POSITIVE_INFINITY });
+}
+/** Horizontal flex line over plain `Box` cells. */
+export function row(c, items, opts = {}) {
+    return line(c, items, opts, "x");
+}
+/** Vertical flex line over plain `Box` cells. */
+export function col(c, items, opts = {}) {
+    return line(c, items, opts, "y");
+}
+function line(c, rawItems, opts, main) {
+    const items = specs(rawItems);
+    const horizontal = main === "x";
+    const mainPos = (b) => asW(horizontal ? b.x : b.y);
+    const mainSize = (b) => asW(horizontal ? b.w : b.h);
+    const crossPos = (b) => asW(horizontal ? b.y : b.x);
+    const crossSize = (b) => asW(horizontal ? b.h : b.w);
+    const align = opts.align ?? "stretch";
+    const reads = [
+        mainPos(c),
+        mainSize(c),
+        crossPos(c),
+        crossSize(c),
+        ...items.map(it => crossSize(it.box)),
+        ...readDeps(opts.gap ?? 0, opts.padding ?? 0),
+    ];
+    const writes = [];
+    for (const it of items) {
+        writes.push(mainPos(it.box), mainSize(it.box), crossPos(it.box));
+        if (align === "stretch")
+            writes.push(crossSize(it.box));
+    }
+    if (typeof opts.report !== "function" && opts.report)
+        writes.push(opts.report);
+    return propagator(reads, writes, () => {
+        const gap = readNow(opts.gap ?? 0);
+        const pad = readNow(opts.padding ?? 0);
+        const n = items.length;
+        if (n === 0)
+            return;
+        const content = mainSize(c).value - 2 * pad - (n - 1) * gap;
+        const mins = items.map(it => it.min);
+        const maxs = items.map(it => it.max);
+        const sumMin = mins.reduce((a, b) => a + b, 0);
+        const sumMax = maxs.reduce((a, b) => a + b, 0);
+        // Phase 1 — feasibility. Per-item band from the `total` relation:
+        //   wᵢ ∈ [content − Σmax(others), content − Σmin(others)] ∩ [minᵢ, maxᵢ].
+        const bands = items.map((_, i) => {
+            const lo = content - (sumMax - maxs[i]);
+            const hi = content - (sumMin - mins[i]);
+            return interval.meet([Math.max(lo, mins[i]), Math.min(hi, maxs[i])], [mins[i], maxs[i]]);
+        });
+        const infeasible = content < sumMin - 1e-9 || bands.some(interval.isBottom);
+        report(opts, infeasible);
+        // Phase 2 — resolution. Distribute slack from the basis sizes,
+        // weighted by grow (free > 0) / shrink (free < 0), clamped into the
+        // feasible band each pass and redistributed.
+        const base = items.map((it, i) => clamp(it.basis ?? mainSize(it.box).value, mins[i], maxs[i]));
+        const sizes = distribute(base, items, mins, maxs, content);
+        let cursor = mainPos(c).value + pad;
+        for (let i = 0; i < n; i++) {
+            mainPos(items[i].box).value = cursor;
+            mainSize(items[i].box).value = sizes[i];
+            cursor += sizes[i] + gap;
+        }
+        const cBase = crossPos(c).value + pad;
+        const cAvail = crossSize(c).value - 2 * pad;
+        for (const it of items) {
+            const itSize = crossSize(it.box).value;
+            switch (align) {
+                case "start":
+                    crossPos(it.box).value = cBase;
+                    break;
+                case "center":
+                    crossPos(it.box).value = cBase + (cAvail - itSize) / 2;
+                    break;
+                case "end":
+                    crossPos(it.box).value = cBase + cAvail - itSize;
+                    break;
+                case "stretch":
+                    crossPos(it.box).value = cBase;
+                    crossSize(it.box).value = cAvail;
+                    break;
+            }
+        }
+    });
+}
+/** CSS-flex slack distribution, clamped into [min, max] with overflow
+ *  redistributed across still-eligible items. */
+function distribute(base, items, mins, maxs, content) {
+    const n = base.length;
+    const sizes = base.slice();
+    const free = content - base.reduce((a, b) => a + b, 0);
+    if (free > 1e-9) {
+        let remaining = free;
+        const eligible = new Set();
+        for (let i = 0; i < n; i++)
+            if (items[i].grow > 0 && sizes[i] < maxs[i])
+                eligible.add(i);
+        while (remaining > 1e-9 && eligible.size > 0) {
+            let weight = 0;
+            for (const i of eligible)
+                weight += items[i].grow;
+            if (weight === 0)
+                break;
+            let absorbed = 0;
+            for (const i of [...eligible]) {
+                const next = Math.min(sizes[i] + (remaining * items[i].grow) / weight, maxs[i]);
+                absorbed += next - sizes[i];
+                sizes[i] = next;
+                if (next >= maxs[i])
+                    eligible.delete(i);
+            }
+            if (absorbed < 1e-9)
+                break;
+            remaining -= absorbed;
+        }
+    }
+    else if (free < -1e-9) {
+        let remaining = -free;
+        const eligible = new Set();
+        for (let i = 0; i < n; i++)
+            if (items[i].shrink > 0 && sizes[i] > mins[i])
+                eligible.add(i);
+        while (remaining > 1e-9 && eligible.size > 0) {
+            let weight = 0;
+            for (const i of eligible)
+                weight += items[i].shrink;
+            if (weight === 0)
+                break;
+            let absorbed = 0;
+            for (const i of [...eligible]) {
+                const next = Math.max(sizes[i] - (remaining * items[i].shrink) / weight, mins[i]);
+                absorbed += sizes[i] - next;
+                sizes[i] = next;
+                if (next <= mins[i])
+                    eligible.delete(i);
+            }
+            if (absorbed < 1e-9)
+                break;
+            remaining -= absorbed;
+        }
+    }
+    return sizes;
+}
+function report(opts, infeasible) {
+    if (typeof opts.report === "function")
+        opts.report(infeasible);
+    else if (opts.report)
+        asW(opts.report).value = infeasible ? 1 : 0;
+}

package/dist/propagators/graph.d.ts

@@ -0,0 +1,73 @@
+/** A directed graph. Edges are `[from, to]`; nodes carry any identity. */
+export interface Graph<N> {
+    readonly nodes: readonly N[];
+    readonly edges: readonly (readonly [N, N])[];
+}
+export type Direction = "TB" | "BT" | "LR" | "RL";
+/** Intrinsic size of a node's box. */
+export interface Size {
+    w: number;
+    h: number;
+}
+/** Top-left placement of a node's box. */
+export interface Placement {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface LayeredOpts<N> {
+    direction?: Direction;
+    /** Centre-to-centre distance between adjacent layers. Default 90. */
+    layerGap?: number;
+    /** Minimum edge-to-edge distance within a layer. Default 28. */
+    nodeGap?: number;
+    /** Intrinsic node size. Default 46×34. */
+    sizeOf?: (n: N) => Size;
+    /** Crossing-reduction sweeps. Default 6. */
+    sweeps?: number;
+    /** Barycenter source: "both" (DAG), "down" (parents over children,
+     *  the tree look), "up". Default "both". */
+    align?: "both" | "down" | "up";
+}
+/** Assign each node an integer layer so every edge increases layer by
+ *  ≥1. Cycles are broken (back edges reversed for ranking only). The
+ *  value is the longest path from a source — computed as the lower
+ *  bound the `order` atoms narrow each layer cell to. */
+export declare function rank<N>(g: Graph<N>): Map<N, number>;
+/** Strongly-connected components (Tarjan), each a list of mutually
+ *  reachable nodes, in reverse-topological order of the condensation.
+ *  Singletons are size-1 components; a self-loop still reports size 1.
+ *  The cyclic cores of a graph are exactly the components of size > 1. */
+export declare function scc<N>(g: Graph<N>): N[][];
+/** Count edge crossings given per-layer orderings (for tests / quality). */
+export declare function crossings<N>(g: Graph<N>, layer: Map<N, number>, layers: N[][]): number;
+/** Full layered layout → top-left placement per node. */
+export declare function layered<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+/** Tree layout: parents centred over their children. A `layered` with
+ *  downward barycenter and tighter defaults. */
+export declare function tree<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+/** Radial layout: layers become concentric rings, cross-axis position
+ *  becomes angle. Reads a `layered` (TB) result and re-maps to polar. */
+export declare function radial<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+/** Recurrent-hierarchy layout: decompose into strongly-connected
+ *  components, lay the condensation (a DAG of SCCs) out hierarchically,
+ *  and draw every cyclic component as a ring centred on its condensation
+ *  slot. The cycle closes by going around the circle — no backward edge.
+ *  Singleton components are placed as ordinary nodes. */
+export declare function recurrent<N>(g: Graph<N>, opts?: LayeredOpts<N>): Map<N, Placement>;
+export interface LanesOpts<N> {
+    /** Row height (topological order axis). Default 56. */
+    rowGap?: number;
+    /** Lane width (column axis). Default 46. */
+    laneGap?: number;
+    sizeOf?: (n: N) => Size;
+}
+/** Git-style lane packing: nodes flow top-to-bottom in topological
+ *  order (one row each), each assigned the first free column ("lane")
+ *  that no live edge occupies. Branch points open lanes, merges free
+ *  them. Expects a DAG whose `nodes` are in commit order (parents
+ *  before children). */
+export declare function lanes<N>(g: Graph<N>, opts?: LanesOpts<N>): Map<N, Placement>;
+/** Bounding size of a placement map. */
+export declare function extent<N>(p: Map<N, Placement>): Size;