bireactive 0.2.1 → 0.2.2

package/README.md

@@ -1,8 +1,8 @@
 # bi-reactive
 
-Reactive programming where edges can go both ways. Write to an input and
-everything derived from it updates; write the *derived* value and the input
-adjusts to match. Forward and backward propagation are handled by the engine, with the same set of caveats as regular reactive programming.
+[npm](https://www.npmjs.com/package/bireactive) · [GitHub](https://github.com/OrionReed/bireactive) · [site](https://orionreed.github.io/bireactive/)
+
+A signals-like bidirectional reactive programming system where edges can go both ways. Forward and backward propagation are handled by the engine, with the same set of caveats as regular reactive programming.
 
 ## Install
 

package/dist/core/values/num.d.ts

@@ -25,6 +25,12 @@ export declare class Num extends Cell<V> {
     /** Affine `v ↦ k·v + off`. Invertible iff k ≠ 0; readability alias
      *  for `.scale(k).add(off)`. */
     affine(k: Val<number>, off: Val<number>): this;
+    /** `sin(this)` (radians). Forward lands in [−1, 1]; the inverse is
+     *  multi-valued, so a write clamps to that domain and returns the
+     *  pre-image nearest the current source — the drag stays on its branch. */
+    sin(): this;
+    /** `exp(this)` — bijection on the reals; inverse is the natural log. */
+    exp(): this;
     /** Lossy clamping lens to `[lo, hi]`. PutGet only (a write outside
      *  the range reads back clamped, not as written). */
     clamp(lo: Val<V>, hi: Val<V>): this;

package/dist/core/values/num.js

@@ -11,6 +11,11 @@ export const scale = (a, k) => a * k;
 export const lerp = (a, b, t) => a + (b - a) * t;
 export const metric = (a, b) => Math.abs(a - b);
 export const equals = (a, b) => a === b;
+const TAU = 2 * Math.PI;
+/** Representative of `x + 2πk` nearest `s` (shortest-arc branch pick). */
+const nearestTo = (s, x) => x + TAU * Math.round((s - x) / TAU);
+/** Clamp to the sin/cos domain `[-1, 1]`. */
+const unit = (t) => (t < -1 ? -1 : t > 1 ? 1 : t);
 const linearImpl = { add, sub, scale };
 const packImpl = {
     dim: 1,
@@ -49,6 +54,21 @@ export class Num extends Cell {
         const of = reader(off);
         return this.lens(v => v * kf() + of(), n => (n - of()) / kf());
     }
+    /** `sin(this)` (radians). Forward lands in [−1, 1]; the inverse is
+     *  multi-valued, so a write clamps to that domain and returns the
+     *  pre-image nearest the current source — the drag stays on its branch. */
+    sin() {
+        return this.lens(v => Math.sin(v), (target, s) => {
+            const p = Math.asin(unit(target));
+            const a = nearestTo(s, p);
+            const b = nearestTo(s, Math.PI - p);
+            return Math.abs(a - s) <= Math.abs(b - s) ? a : b;
+        });
+    }
+    /** `exp(this)` — bijection on the reals; inverse is the natural log. */
+    exp() {
+        return this.lens(v => Math.exp(v), n => Math.log(n));
+    }
     /** Lossy clamping lens to `[lo, hi]`. PutGet only (a write outside
      *  the range reads back clamped, not as written). */
     clamp(lo, hi) {

package/dist/core/values/tri.d.ts

@@ -17,13 +17,15 @@ export declare class Tri extends Cell<V> {
     constructor(v?: V);
     /** Kleene negation. Involution; fixed at `"mixed"`. */
     not(): this;
-    /** Aggregate over N writable Bools. Read: all-true → `true`,
-     *  all-false → `false`, disagreement → `"mixed"`. Write: `true` /
-     *  `false` broadcast to every parent; `"mixed"` is a no-op. */
-    static allOf(parents: readonly Bool[]): Writable<Tri>;
-    /** Dual of `allOf` (Kleene OR): any-true → `true`, all-false →
-     *  `false`, else `"mixed"`. Same broadcast write policy. */
-    static anyOf(parents: readonly Bool[]): Writable<Tri>;
+    /** Aggregate over N writable `Bool` / `Tri` children. Read: all-true →
+     *  `true`, all-false → `false`, any disagreement (or any child already
+     *  `"mixed"`) → `"mixed"`. Write: `true` / `false` broadcast to every
+     *  child, recursing through nested aggregates; `"mixed"` is a no-op. */
+    static allOf(parents: readonly (Bool | Tri)[]): Writable<Tri>;
+    /** Dual of `allOf` (Kleene OR) over `Bool` / `Tri` children: any-true →
+     *  `true`, all-false → `false`, else (or any child `"mixed"`) →
+     *  `"mixed"`. Same broadcast write policy. */
+    static anyOf(parents: readonly (Bool | Tri)[]): Writable<Tri>;
 }
 /** Writable `Tri`. Strict factory: `Tri.value | Writable<Tri>` in,
  *  `Writable<Tri>` out. Default initial value is `"mixed"`. */

package/dist/core/values/tri.js

@@ -3,12 +3,6 @@
 // `Tri.value ∈ { true, false, "mixed" }` — Bool plus an unknown state
 // fixed under negation. Strong-Kleene AND/OR follow the partial-info
 // reading (`mixed AND false` → `false`, `mixed AND true` → `mixed`).
-//
-// Headline use: aggregate N booleans via `Tri.allOf` / `Tri.anyOf`
-// (all-agree → that value, disagreement → `"mixed"`). Writing the
-// aggregate broadcasts to every parent ("select all" / "deselect all");
-// writing `"mixed"` is a no-op. Morally `Maybe<Bool>` — the basis for
-// mixed-state checkbox trees and "loading" predicate states.
 import { Cell } from "../cell.js";
 const equals = (a, b) => a === b;
 /** Kleene negation: `true` / `false` swap, `"mixed"` is fixed. */
@@ -40,14 +34,17 @@ export class Tri extends Cell {
     not() {
         return this.lens(not, not);
     }
-    /** Aggregate over N writable Bools. Read: all-true → `true`,
-     *  all-false → `false`, disagreement → `"mixed"`. Write: `true` /
-     *  `false` broadcast to every parent; `"mixed"` is a no-op. */
+    /** Aggregate over N writable `Bool` / `Tri` children. Read: all-true →
+     *  `true`, all-false → `false`, any disagreement (or any child already
+     *  `"mixed"`) → `"mixed"`. Write: `true` / `false` broadcast to every
+     *  child, recursing through nested aggregates; `"mixed"` is a no-op. */
     static allOf(parents) {
         return Tri.lens(parents, (vs) => {
             let anyT = false;
             let anyF = false;
             for (const v of vs) {
+                if (v === "mixed")
+                    return "mixed";
                 if (v)
                     anyT = true;
                 else
@@ -62,13 +59,16 @@ export class Tri extends Cell {
             return parents.map(() => target);
         });
     }
-    /** Dual of `allOf` (Kleene OR): any-true → `true`, all-false →
-     *  `false`, else `"mixed"`. Same broadcast write policy. */
+    /** Dual of `allOf` (Kleene OR) over `Bool` / `Tri` children: any-true →
+     *  `true`, all-false → `false`, else (or any child `"mixed"`) →
+     *  `"mixed"`. Same broadcast write policy. */
     static anyOf(parents) {
         return Tri.lens(parents, (vs) => {
             let anyT = false;
             let anyF = false;
             for (const v of vs) {
+                if (v === "mixed")
+                    return "mixed";
                 if (v)
                     anyT = true;
                 else

package/dist/core/values/vec.d.ts

@@ -14,6 +14,8 @@ export declare const metric: (a: V, b: V) => number;
 export declare const equals: (a: V, b: V) => boolean;
 export declare const normalize: (v: V) => V;
 export declare const perp: (v: V) => V;
+export declare const rotateAbout: (v: V, p: V, dθ: number) => V;
+export declare const scaleAbout: (v: V, p: V, k: number) => V;
 /** Tangent point on the circle (radius `r`, centre `c`) from external
  *  point `p`. `side: -1` picks the CCW tangent from `pc`, `+1` the CW
  *  (y-down screen coords flip the visual sense). Returns `c` if `p` is
@@ -32,7 +34,12 @@ export declare class Vec extends Cell<V> {
     constructor(v?: V);
     add(b: Val<V>): this;
     sub(b: Val<V>): this;
-    scale(k: Val<number>): this;
+    /** Uniform scale by `k` about `pivot` (default origin). Inverse scales
+     *  by `1/k`; exact bijection for `k ≠ 0`. */
+    scale(k: Val<number>, pivot?: Val<V>): this;
+    /** Rotate by `angle` (radians) about `pivot` (default origin). Inverse
+     *  rotates by `−angle`; exact bijection. */
+    rotate(angle: Val<number>, pivot?: Val<V>): this;
     offset(dx: Val<number>, dy: Val<number>): this;
     up(n: Val<number>): this;
     down(n: Val<number>): this;

package/dist/core/values/vec.js

@@ -20,6 +20,18 @@ export const normalize = (v) => {
     return m === 0 ? { x: 0, y: 0 } : { x: v.x / m, y: v.y / m };
 };
 export const perp = (v) => ({ x: v.y, y: -v.x });
+export const rotateAbout = (v, p, dθ) => {
+    const cos = Math.cos(dθ);
+    const sin = Math.sin(dθ);
+    const dx = v.x - p.x;
+    const dy = v.y - p.y;
+    return { x: p.x + cos * dx - sin * dy, y: p.y + sin * dx + cos * dy };
+};
+export const scaleAbout = (v, p, k) => ({
+    x: p.x + k * (v.x - p.x),
+    y: p.y + k * (v.y - p.y),
+});
+const ORIGIN = { x: 0, y: 0 };
 /** Tangent point on the circle (radius `r`, centre `c`) from external
  *  point `p`. `side: -1` picks the CCW tangent from `pc`, `+1` the CW
  *  (y-down screen coords flip the visual sense). Returns `c` if `p` is
@@ -49,19 +61,7 @@ const packImpl = {
     },
     write: (a, o) => ({ x: a[o], y: a[o + 1] }),
 };
-const pivotalImpl = {
-    rotateAbout: (v, p, dθ) => {
-        const cos = Math.cos(dθ);
-        const sin = Math.sin(dθ);
-        const dx = v.x - p.x;
-        const dy = v.y - p.y;
-        return { x: p.x + cos * dx - sin * dy, y: p.y + sin * dx + cos * dy };
-    },
-    scaleAbout: (v, p, k) => ({
-        x: p.x + k * (v.x - p.x),
-        y: p.y + k * (v.y - p.y),
-    }),
-};
+const pivotalImpl = { rotateAbout, scaleAbout };
 export class Vec extends Cell {
     static traits = {
         linear: linearImpl,
@@ -94,16 +94,26 @@ export class Vec extends Cell {
             return { x: n.x + o.x, y: n.y + o.y };
         });
     }
-    scale(k) {
+    /** Uniform scale by `k` about `pivot` (default origin). Inverse scales
+     *  by `1/k`; exact bijection for `k ≠ 0`. */
+    scale(k, pivot) {
         const kf = reader(k);
+        const pf = pivot === undefined ? undefined : reader(pivot);
         return this.lens(v => {
             const k = kf();
-            return { x: v.x * k, y: v.y * k };
+            return pf ? scaleAbout(v, pf(), k) : { x: v.x * k, y: v.y * k };
         }, n => {
             const k = kf();
-            return { x: n.x / k, y: n.y / k };
+            return pf ? scaleAbout(n, pf(), 1 / k) : { x: n.x / k, y: n.y / k };
         });
     }
+    /** Rotate by `angle` (radians) about `pivot` (default origin). Inverse
+     *  rotates by `−angle`; exact bijection. */
+    rotate(angle, pivot = ORIGIN) {
+        const af = reader(angle);
+        const pf = reader(pivot);
+        return this.lens(v => rotateAbout(v, pf(), af()), n => rotateAbout(n, pf(), -af()));
+    }
     offset(dx, dy) {
         const xf = reader(dx);
         const yf = reader(dy);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bireactive",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Bi-directional reactive programming.",
   "type": "module",
   "main": "./src/index.ts",