@rhi-zone/rainbow 0.1.0

package/dist/async-data.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AsyncData<T, E> — the type of an asynchronous value.
+ *
+ * Four states:
+ *   notAsked — not yet requested
+ *   loading  — request in flight
+ *   failure  — completed with error
+ *   success  — completed with value
+ *
+ * Modelled as a discriminated union so exhaustive pattern matching is
+ * enforced by the type system.
+ */
+export type AsyncData<T, E = unknown> = {
+    readonly status: 'notAsked';
+} | {
+    readonly status: 'loading';
+} | {
+    readonly status: 'failure';
+    readonly error: E;
+} | {
+    readonly status: 'success';
+    readonly value: T;
+};
+export declare const notAsked: AsyncData<never, never>;
+export declare const loading: AsyncData<never, never>;
+export declare const failure: <E>(error: E) => AsyncData<never, E>;
+export declare const success: <T>(value: T) => AsyncData<T, never>;
+export declare const isNotAsked: <T, E>(ad: AsyncData<T, E>) => ad is {
+    status: 'notAsked';
+};
+export declare const isLoading: <T, E>(ad: AsyncData<T, E>) => ad is {
+    status: 'loading';
+};
+export declare const isFailure: <T, E>(ad: AsyncData<T, E>) => ad is {
+    status: 'failure';
+    error: E;
+};
+export declare const isSuccess: <T, E>(ad: AsyncData<T, E>) => ad is {
+    status: 'success';
+    value: T;
+};
+/** Transform the success value, leaving other states untouched. */
+export declare const map: <T, U, E>(ad: AsyncData<T, E>, f: (value: T) => U) => AsyncData<U, E>;
+/** Transform the error value, leaving other states untouched. */
+export declare const mapError: <T, E, F>(ad: AsyncData<T, E>, f: (error: E) => F) => AsyncData<T, F>;
+/** Chain async operations — flatMap over the success case. */
+export declare const chain: <T, U, E>(ad: AsyncData<T, E>, f: (value: T) => AsyncData<U, E>) => AsyncData<U, E>;
+/** Unwrap with a fallback for non-success states. */
+export declare const getOrElse: <T, E>(ad: AsyncData<T, E>, fallback: T) => T;
+/** Fold over all four states. */
+export declare const fold: <T, E, R>(ad: AsyncData<T, E>, cases: {
+    notAsked: () => R;
+    loading: () => R;
+    failure: (error: E) => R;
+    success: (value: T) => R;
+}) => R;

package/dist/async-data.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/computed.d.ts

@@ -0,0 +1,8 @@
+import type { ReadonlySignal } from './signal.ts';
+/**
+ * Derive a read-only signal from multiple source signals.
+ *
+ * Unlike signal.map (one source), computed accepts any number of sources
+ * and recomputes when any of them change.
+ */
+export declare function computed<T>(fn: () => T, deps: ReadonlySignal<unknown>[]): ReadonlySignal<T>;

package/dist/computed.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cond.d.ts

@@ -0,0 +1,18 @@
+import type { ReadonlySignal } from './signal.ts';
+/**
+ * Conditional signal — propagates the value when `pred` holds, undefined otherwise.
+ *
+ * Accepts both `ReadonlySignal<A>` and `ReadonlySignal<A | undefined>` so that
+ * cond calls can be composed directly:
+ *
+ *   cond(p, cond(q, w))  ≡  cond(x => q(x) && p(x), w)
+ *
+ * When the source already carries `undefined` (from a prior `cond` or `narrow`),
+ * undefined passes through unchanged — equivalent to short-circuit `&&`.
+ *
+ * Usage:
+ *   const positiveCount = cond(n => n > 0, countSignal)
+ *   const positiveEven  = cond(n => n % 2 === 0, positiveCount)
+ */
+export declare function cond<A>(pred: (a: A) => boolean, s: ReadonlySignal<A>): ReadonlySignal<A | undefined>;
+export declare function cond<A>(pred: (a: A) => boolean, s: ReadonlySignal<A | undefined>): ReadonlySignal<A | undefined>;

package/dist/cond.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export type { Lens } from './lens.ts';
+export { lens, composeLens, field, fst, snd, id } from './lens.ts';
+export type { Prism } from './prism.ts';
+export { prism, composePrism, some, iso } from './prism.ts';
+export type { Signal, ReadonlySignal } from './signal.ts';
+export { signal, batch } from './signal.ts';
+export { computed } from './computed.ts';
+export { cond } from './cond.ts';
+export { product, stateful } from './product.ts';
+export type { Traversal } from './traversal.ts';
+export { traversal, each, filtered, nth, composeWithLens, composeTraversal } from './traversal.ts';
+export type { AsyncData } from './async-data.ts';
+export { notAsked, loading, failure, success, isNotAsked, isLoading, isFailure, isSuccess, map as mapAsyncData, mapError, chain as chainAsyncData, getOrElse, fold, } from './async-data.ts';

package/dist/laws.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lens.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A Lens<A, B> focuses on a field of type B within a structure of type A.
+ *
+ * Laws:
+ *   get(set(a, b)) = b
+ *   set(a, get(a)) = a
+ *   set(set(a, b1), b2) = set(a, b2)
+ */
+export interface Lens<A, B> {
+    get(a: A): B;
+    set(a: A, b: B): A;
+}
+export declare function lens<A, B>(get: (a: A) => B, set: (a: A, b: B) => A): Lens<A, B>;
+export declare function composeLens<A, B, C>(ab: Lens<A, B>, bc: Lens<B, C>): Lens<A, C>;
+/** Lens into the first element of a tuple */
+export declare const fst: <A, B>() => Lens<[A, B], A>;
+/** Lens into the second element of a tuple */
+export declare const snd: <A, B>() => Lens<[A, B], B>;
+/** Lens into a record field */
+export declare function field<A, K extends keyof A>(key: K): Lens<A, A[K]>;
+/** Identity lens */
+export declare function id<A>(): Lens<A, A>;

package/dist/lens.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/prism.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A Prism<A, B> focuses on a case of type B within a sum type A.
+ *
+ * Laws:
+ *   match(inject(b)) = b
+ *   if match(a) = b then inject(b) = a
+ */
+export interface Prism<A, B> {
+    match(a: A): B | undefined;
+    inject(b: B): A;
+}
+export declare function prism<A, B>(match: (a: A) => B | undefined, inject: (b: B) => A): Prism<A, B>;
+export declare function composePrism<A, B, C>(ab: Prism<A, B>, bc: Prism<B, C>): Prism<A, C>;
+/** Prism for the Some case of an optional value */
+export declare function some<A>(): Prism<A | undefined, A>;
+/** Prism that always matches (isomorphism) */
+export declare function iso<A, B>(to: (a: A) => B, from: (b: B) => A): Prism<A, B>;

package/dist/prism.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/product.d.ts

@@ -0,0 +1,19 @@
+import type { Signal } from './signal.ts';
+/**
+ * Create a signal over a pair [A, B] backed by two independent signals.
+ */
+export declare function product<A, B>(a: Signal<A>, b: Signal<B>): Signal<[A, B]>;
+/**
+ * Encapsulate internal state S alongside external signal A.
+ *
+ * The S state starts as `init` and lives locally — not accessible
+ * from outside except via the returned signal's focus(fst()) / focus(snd()).
+ *
+ * Unicorn equivalent: `stateful init widget`
+ *
+ * Usage:
+ *   const combined = stateful("", itemsSignal)  // Signal<[string, Item[]]>
+ *   const draft = combined.focus(fst())          // Signal<string>  — local
+ *   const items = combined.focus(snd())          // Signal<Item[]>  — external
+ */
+export declare function stateful<S, A>(init: S, outer: Signal<A>): Signal<[S, A]>;

package/dist/product.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rainbow.js

@@ -0,0 +1,358 @@
+var d = Object.defineProperty;
+var w = (s, t, e) => t in s ? d(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var u = (s, t, e) => w(s, typeof t != "symbol" ? t + "" : t, e);
+function _(s, t) {
+  return { get: s, set: t };
+}
+function P(s, t) {
+  return {
+    get: (e) => t.get(s.get(e)),
+    set: (e, r) => s.set(e, t.set(s.get(e), r))
+  };
+}
+const z = () => _(([s]) => s, ([, s], t) => [t, s]), C = () => _(([, s]) => s, ([s], t) => [s, t]);
+function F(s) {
+  return _(
+    (t) => t[s],
+    (t, e) => ({ ...t, [s]: e })
+  );
+}
+function N() {
+  return _((s) => s, (s, t) => t);
+}
+function p(s, t) {
+  return { match: s, inject: t };
+}
+function R(s, t) {
+  return {
+    match: (e) => {
+      const r = s.match(e);
+      return r !== void 0 ? t.match(r) : void 0;
+    },
+    inject: (e) => s.inject(t.inject(e))
+  };
+}
+function T() {
+  return p(
+    (s) => s,
+    (s) => s
+  );
+}
+function W(s, t) {
+  return p(s, t);
+}
+let l = 0;
+const f = /* @__PURE__ */ new Map();
+function v(s) {
+  l++;
+  try {
+    s();
+  } finally {
+    if (l--, l === 0)
+      for (; f.size > 0; ) {
+        const t = [...f.values()];
+        f.clear();
+        for (const e of t) e();
+      }
+  }
+}
+class A {
+  constructor(t) {
+    u(this, "_value");
+    u(this, "_subscribers", /* @__PURE__ */ new Set());
+    this._value = t;
+  }
+  get() {
+    return this._value;
+  }
+  set(t) {
+    if (!Object.is(this._value, t))
+      if (this._value = t, l > 0)
+        for (const e of this._subscribers)
+          f.set(e, () => e(this._value));
+      else
+        for (const e of this._subscribers) e(t);
+  }
+  subscribe(t) {
+    return this._subscribers.add(t), () => this._subscribers.delete(t);
+  }
+  map(t) {
+    return new c(this, t);
+  }
+  focus(t) {
+    return new o(this, t);
+  }
+  narrow(t) {
+    return new a(this, t);
+  }
+}
+class c {
+  constructor(t, e) {
+    u(this, "_source");
+    u(this, "_f");
+    this._source = t, this._f = e;
+  }
+  get() {
+    return this._f(this._source.get());
+  }
+  subscribe(t) {
+    let e = this.get();
+    return this._source.subscribe(() => {
+      const r = this.get();
+      Object.is(e, r) || (e = r, t(r));
+    });
+  }
+  map(t) {
+    return new c(this, t);
+  }
+}
+class o {
+  constructor(t, e) {
+    u(this, "_source");
+    u(this, "_lens");
+    this._source = t, this._lens = e;
+  }
+  get() {
+    return this._lens.get(this._source.get());
+  }
+  set(t) {
+    this._source.set(this._lens.set(this._source.get(), t));
+  }
+  subscribe(t) {
+    let e = this.get();
+    return this._source.subscribe(() => {
+      const r = this.get();
+      Object.is(e, r) || (e = r, t(r));
+    });
+  }
+  map(t) {
+    return new c(this, t);
+  }
+  focus(t) {
+    return new o(this, t);
+  }
+  narrow(t) {
+    return new a(this, t);
+  }
+}
+class a {
+  constructor(t, e) {
+    u(this, "_source");
+    u(this, "_prism");
+    this._source = t, this._prism = e;
+  }
+  get() {
+    return this._prism.match(this._source.get());
+  }
+  set(t) {
+    t !== void 0 && this._source.set(this._prism.inject(t));
+  }
+  subscribe(t) {
+    let e = this.get();
+    return this._source.subscribe(() => {
+      const r = this.get();
+      Object.is(e, r) || (e = r, t(r));
+    });
+  }
+  map(t) {
+    return new c(this, t);
+  }
+  focus(t) {
+    return new o(this, t);
+  }
+  narrow(t) {
+    return new a(this, t);
+  }
+}
+function m(s) {
+  return new A(s);
+}
+function j(s, t) {
+  return new o(s, t);
+}
+function k(s, t) {
+  return new a(s, t);
+}
+function y(s, t) {
+  return new O(s, t);
+}
+class O {
+  constructor(t, e) {
+    u(this, "_fn");
+    u(this, "_deps");
+    this._fn = t, this._deps = e;
+  }
+  get() {
+    return this._fn();
+  }
+  subscribe(t) {
+    let e = this.get();
+    const r = this._deps.map(
+      (n) => n.subscribe(() => {
+        const i = this.get();
+        Object.is(e, i) || (e = i, t(i));
+      })
+    );
+    return () => r.forEach((n) => n());
+  }
+  map(t) {
+    return y(() => t(this.get()), [this]);
+  }
+}
+function q(s, t) {
+  return t.map((e) => e !== void 0 && s(e) ? e : void 0);
+}
+class S {
+  constructor(t, e) {
+    this._a = t, this._b = e;
+  }
+  get() {
+    return [this._a.get(), this._b.get()];
+  }
+  set([t, e]) {
+    v(() => {
+      this._a.set(t), this._b.set(e);
+    });
+  }
+  subscribe(t) {
+    const e = () => t(this.get()), r = this._a.subscribe(e), n = this._b.subscribe(e);
+    return () => {
+      r(), n();
+    };
+  }
+  map(t) {
+    let e = t(this.get());
+    const r = m(e);
+    return this.subscribe((n) => {
+      const i = t(n);
+      Object.is(e, i) || (e = i, r.set(i));
+    }), r;
+  }
+  focus(t) {
+    return j(this, t);
+  }
+  narrow(t) {
+    return k(this, t);
+  }
+}
+function x(s, t) {
+  return new S(s, t);
+}
+function B(s, t) {
+  return x(m(s), t);
+}
+function h(s, t) {
+  return { getAll: s, modify: t };
+}
+function G() {
+  return h(
+    (s) => [...s],
+    (s, t) => s.map(t)
+  );
+}
+function H(s) {
+  return h(
+    (t) => t.filter(s),
+    (t, e) => t.map((r) => s(r) ? e(r) : r)
+  );
+}
+function I(s) {
+  return h(
+    (t) => t.filter((e, r) => r === s),
+    (t, e) => t.map((r, n) => n === s ? e(r) : r)
+  );
+}
+function J(s, t) {
+  return h(
+    (e) => t.getAll(s.get(e)),
+    (e, r) => s.set(e, t.modify(s.get(e), r))
+  );
+}
+function K(s, t) {
+  return h(
+    (e) => s.getAll(e).flatMap((r) => t.getAll(r)),
+    (e, r) => s.modify(e, (n) => t.modify(n, r))
+  );
+}
+const g = { status: "notAsked" }, b = { status: "loading" }, D = (s) => ({ status: "failure", error: s }), E = (s) => ({ status: "success", value: s }), Q = (s) => s.status === "notAsked", U = (s) => s.status === "loading", V = (s) => s.status === "failure", L = (s) => s.status === "success", X = (s, t) => {
+  switch (s.status) {
+    case "success":
+      return E(t(s.value));
+    case "failure":
+      return s;
+    case "loading":
+      return b;
+    case "notAsked":
+      return g;
+  }
+}, Y = (s, t) => {
+  switch (s.status) {
+    case "failure":
+      return D(t(s.error));
+    case "success":
+      return s;
+    case "loading":
+      return b;
+    case "notAsked":
+      return g;
+  }
+}, Z = (s, t) => {
+  switch (s.status) {
+    case "success":
+      return t(s.value);
+    case "failure":
+      return s;
+    case "loading":
+      return b;
+    case "notAsked":
+      return g;
+  }
+}, $ = (s, t) => L(s) ? s.value : t, tt = (s, t) => {
+  switch (s.status) {
+    case "notAsked":
+      return t.notAsked();
+    case "loading":
+      return t.loading();
+    case "failure":
+      return t.failure(s.error);
+    case "success":
+      return t.success(s.value);
+  }
+};
+export {
+  v as batch,
+  Z as chainAsyncData,
+  P as composeLens,
+  R as composePrism,
+  K as composeTraversal,
+  J as composeWithLens,
+  y as computed,
+  q as cond,
+  G as each,
+  D as failure,
+  F as field,
+  H as filtered,
+  tt as fold,
+  z as fst,
+  $ as getOrElse,
+  N as id,
+  V as isFailure,
+  U as isLoading,
+  Q as isNotAsked,
+  L as isSuccess,
+  W as iso,
+  _ as lens,
+  b as loading,
+  X as mapAsyncData,
+  Y as mapError,
+  g as notAsked,
+  I as nth,
+  p as prism,
+  x as product,
+  m as signal,
+  C as snd,
+  T as some,
+  B as stateful,
+  E as success,
+  h as traversal
+};

package/dist/rainbow.umd.cjs

@@ -0,0 +1 @@
+(function(n,i){typeof exports=="object"&&typeof module<"u"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(n=typeof globalThis<"u"?globalThis:n||self,i(n.Rainbow={}))})(this,(function(n){"use strict";var x=Object.defineProperty;var tt=(n,i,a)=>i in n?x(n,i,{enumerable:!0,configurable:!0,writable:!0,value:a}):n[i]=a;var c=(n,i,a)=>tt(n,typeof i!="symbol"?i+"":i,a);function i(s,t){return{get:s,set:t}}function a(s,t){return{get:e=>t.get(s.get(e)),set:(e,r)=>s.set(e,t.set(s.get(e),r))}}const O=()=>i(([s])=>s,([,s],t)=>[t,s]),L=()=>i(([,s])=>s,([s],t)=>[s,t]);function E(s){return i(t=>t[s],(t,e)=>({...t,[s]:e}))}function T(){return i(s=>s,(s,t)=>t)}function w(s,t){return{match:s,inject:t}}function P(s,t){return{match:e=>{const r=s.match(e);return r!==void 0?t.match(r):void 0},inject:e=>s.inject(t.inject(e))}}function D(){return w(s=>s,s=>s)}function M(s,t){return w(s,t)}let d=0;const _=new Map;function p(s){d++;try{s()}finally{if(d--,d===0)for(;_.size>0;){const t=[..._.values()];_.clear();for(const e of t)e()}}}class F{constructor(t){c(this,"_value");c(this,"_subscribers",new Set);this._value=t}get(){return this._value}set(t){if(!Object.is(this._value,t))if(this._value=t,d>0)for(const e of this._subscribers)_.set(e,()=>e(this._value));else for(const e of this._subscribers)e(t)}subscribe(t){return this._subscribers.add(t),()=>this._subscribers.delete(t)}map(t){return new f(this,t)}focus(t){return new l(this,t)}narrow(t){return new g(this,t)}}class f{constructor(t,e){c(this,"_source");c(this,"_f");this._source=t,this._f=e}get(){return this._f(this._source.get())}subscribe(t){let e=this.get();return this._source.subscribe(()=>{const r=this.get();Object.is(e,r)||(e=r,t(r))})}map(t){return new f(this,t)}}class l{constructor(t,e){c(this,"_source");c(this,"_lens");this._source=t,this._lens=e}get(){return this._lens.get(this._source.get())}set(t){this._source.set(this._lens.set(this._source.get(),t))}subscribe(t){let e=this.get();return this._source.subscribe(()=>{const r=this.get();Object.is(e,r)||(e=r,t(r))})}map(t){return new f(this,t)}focus(t){return new l(this,t)}narrow(t){return new g(this,t)}}class g{constructor(t,e){c(this,"_source");c(this,"_prism");this._source=t,this._prism=e}get(){return this._prism.match(this._source.get())}set(t){t!==void 0&&this._source.set(this._prism.inject(t))}subscribe(t){let e=this.get();return this._source.subscribe(()=>{const r=this.get();Object.is(e,r)||(e=r,t(r))})}map(t){return new f(this,t)}focus(t){return new l(this,t)}narrow(t){return new g(this,t)}}function v(s){return new F(s)}function N(s,t){return new l(s,t)}function R(s,t){return new g(s,t)}function A(s,t){return new W(s,t)}class W{constructor(t,e){c(this,"_fn");c(this,"_deps");this._fn=t,this._deps=e}get(){return this._fn()}subscribe(t){let e=this.get();const r=this._deps.map(u=>u.subscribe(()=>{const o=this.get();Object.is(e,o)||(e=o,t(o))}));return()=>r.forEach(u=>u())}map(t){return A(()=>t(this.get()),[this])}}function z(s,t){return t.map(e=>e!==void 0&&s(e)?e:void 0)}class C{constructor(t,e){this._a=t,this._b=e}get(){return[this._a.get(),this._b.get()]}set([t,e]){p(()=>{this._a.set(t),this._b.set(e)})}subscribe(t){const e=()=>t(this.get()),r=this._a.subscribe(e),u=this._b.subscribe(e);return()=>{r(),u()}}map(t){let e=t(this.get());const r=v(e);return this.subscribe(u=>{const o=t(u);Object.is(e,o)||(e=o,r.set(o))}),r}focus(t){return N(this,t)}narrow(t){return R(this,t)}}function j(s,t){return new C(s,t)}function q(s,t){return j(v(s),t)}function h(s,t){return{getAll:s,modify:t}}function B(){return h(s=>[...s],(s,t)=>s.map(t))}function G(s){return h(t=>t.filter(s),(t,e)=>t.map(r=>s(r)?e(r):r))}function H(s){return h(t=>t.filter((e,r)=>r===s),(t,e)=>t.map((r,u)=>u===s?e(r):r))}function I(s,t){return h(e=>t.getAll(s.get(e)),(e,r)=>s.set(e,t.modify(s.get(e),r)))}function J(s,t){return h(e=>s.getAll(e).flatMap(r=>t.getAll(r)),(e,r)=>s.modify(e,u=>t.modify(u,r)))}const b={status:"notAsked"},m={status:"loading"},k=s=>({status:"failure",error:s}),y=s=>({status:"success",value:s}),K=s=>s.status==="notAsked",Q=s=>s.status==="loading",U=s=>s.status==="failure",S=s=>s.status==="success",V=(s,t)=>{switch(s.status){case"success":return y(t(s.value));case"failure":return s;case"loading":return m;case"notAsked":return b}},X=(s,t)=>{switch(s.status){case"failure":return k(t(s.error));case"success":return s;case"loading":return m;case"notAsked":return b}},Y=(s,t)=>{switch(s.status){case"success":return t(s.value);case"failure":return s;case"loading":return m;case"notAsked":return b}},Z=(s,t)=>S(s)?s.value:t,$=(s,t)=>{switch(s.status){case"notAsked":return t.notAsked();case"loading":return t.loading();case"failure":return t.failure(s.error);case"success":return t.success(s.value)}};n.batch=p,n.chainAsyncData=Y,n.composeLens=a,n.composePrism=P,n.composeTraversal=J,n.composeWithLens=I,n.computed=A,n.cond=z,n.each=B,n.failure=k,n.field=E,n.filtered=G,n.fold=$,n.fst=O,n.getOrElse=Z,n.id=T,n.isFailure=U,n.isLoading=Q,n.isNotAsked=K,n.isSuccess=S,n.iso=M,n.lens=i,n.loading=m,n.mapAsyncData=V,n.mapError=X,n.notAsked=b,n.nth=H,n.prism=w,n.product=j,n.signal=v,n.snd=L,n.some=D,n.stateful=q,n.success=y,n.traversal=h,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));

package/dist/react.d.ts

@@ -0,0 +1,21 @@
+import type { Signal, ReadonlySignal } from './signal.ts';
+/**
+ * Subscribe to a read-only rainbow signal in a React component.
+ *
+ * Uses useSyncExternalStore for concurrent-mode safety.
+ * The component re-renders whenever the signal value changes.
+ *
+ * Usage:
+ *   const count = useReadonlySignal(activeCount)
+ */
+export declare function useReadonlySignal<A>(s: ReadonlySignal<A>): A;
+/**
+ * Subscribe to a read-write rainbow signal in a React component.
+ *
+ * Returns [currentValue, setter] — analogous to useState, but backed
+ * by a shared signal rather than local component state.
+ *
+ * Usage:
+ *   const [draft, setDraft] = useSignal(draftSignal)
+ */
+export declare function useSignal<A>(s: Signal<A>): [A, (a: A) => void];

package/dist/signal.d.ts

@@ -0,0 +1,34 @@
+import type { Lens } from './lens.ts';
+import type { Prism } from './prism.ts';
+type Subscriber<A> = (value: A) => void;
+/**
+ * Run `fn` synchronously; defer and deduplicate all signal notifications
+ * until `fn` returns, then flush them in one pass.
+ *
+ * Batches may nest — flush only happens when the outermost batch completes.
+ */
+export declare function batch(fn: () => void): void;
+/**
+ * A Signal<A> is a reactive cell holding a value of type A.
+ * Reading tracks the dependency; writing propagates to subscribers.
+ */
+export interface Signal<A> {
+    get(): A;
+    set(a: A): void;
+    subscribe(fn: Subscriber<A>): () => void;
+    /** Read-only derived signal */
+    map<B>(f: (a: A) => B): ReadonlySignal<B>;
+    /** Read-write focused signal via lens */
+    focus<B>(lens: Lens<A, B>): Signal<B>;
+    /** Read-write focused signal via prism (undefined when case doesn't match) */
+    narrow<B>(prism: Prism<A, B>): Signal<B | undefined>;
+}
+export interface ReadonlySignal<A> {
+    get(): A;
+    subscribe(fn: Subscriber<A>): () => void;
+    map<B>(f: (a: A) => B): ReadonlySignal<B>;
+}
+export declare function signal<A>(initial: A): Signal<A>;
+export declare function focusSignal<A, B>(source: Signal<A>, lens: Lens<A, B>): Signal<B>;
+export declare function narrowSignal<A, B>(source: Signal<A>, prism: Prism<A, B>): Signal<B | undefined>;
+export {};

package/dist/signal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/traversal.d.ts

@@ -0,0 +1,23 @@
+import type { Lens } from './lens.ts';
+/**
+ * A Traversal<A, B> focuses on zero or more B values within A.
+ *
+ * Laws:
+ *   modify(a, id) = a
+ *   modify(modify(a, f), g) = modify(a, g ∘ f)   [when f, g commute on elements]
+ */
+export interface Traversal<A, B> {
+    getAll(a: A): B[];
+    modify(a: A, f: (b: B) => B): A;
+}
+export declare function traversal<A, B>(getAll: (a: A) => B[], modify: (a: A, f: (b: B) => B) => A): Traversal<A, B>;
+/** Focus on every element of an array */
+export declare function each<B>(): Traversal<B[], B>;
+/** Focus on elements matching a predicate */
+export declare function filtered<B>(pred: (b: B) => boolean): Traversal<B[], B>;
+/** Focus on a single element by index */
+export declare function nth<B>(index: number): Traversal<B[], B>;
+/** Compose a lens with a traversal */
+export declare function composeWithLens<A, B extends object, C>(lens: Lens<A, B>, t: Traversal<B, C>): Traversal<A, C>;
+/** Compose two traversals */
+export declare function composeTraversal<A, B, C>(ab: Traversal<A, B>, bc: Traversal<B, C>): Traversal<A, C>;

package/dist/traversal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/vue.d.ts

@@ -0,0 +1,30 @@
+import { type Ref } from 'vue';
+import type { Signal, ReadonlySignal } from './signal.ts';
+/**
+ * Adapt a rainbow Signal<A> to a Vue Ref<A>.
+ * Changes to the signal propagate to Vue's reactivity system, and vice versa.
+ */
+export declare function signalToRef<A>(s: Signal<A>): Ref<A>;
+/**
+ * Adapt a rainbow ReadonlySignal<A> to a read-only Vue Ref<A>.
+ */
+export declare function readonlySignalToRef<A>(s: ReadonlySignal<A>): Ref<A>;
+/**
+ * Convert a map of signals to a map of Vue Refs in one call.
+ *
+ * Distinguishes Signal (read-write) from ReadonlySignal (read-only)
+ * via duck-typing on the `set` method.
+ *
+ * Usage:
+ *   const { draft, filteredTodos, activeCount } = useSignals({ draft, filteredTodos, activeCount })
+ */
+export declare function useSignals<T extends Record<string, Signal<unknown> | ReadonlySignal<unknown>>>(signals: T): {
+    [K in keyof T]: Ref<T[K] extends Signal<infer A> | ReadonlySignal<infer A> ? A : never>;
+};
+/**
+ * Adapt a Vue Ref<A> to a rainbow Signal<A>.
+ *
+ * Creates a rainbow signal backed by the ref's current value,
+ * then keeps them in sync bidirectionally.
+ */
+export declare function refToSignal<A>(r: Ref<A>): Signal<A>;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@rhi-zone/rainbow",
+  "version": "0.1.0",
+  "description": "Optics-based reactivity — structured state for the web",
+  "type": "module",
+  "main": "./dist/rainbow.umd.cjs",
+  "module": "./dist/rainbow.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/rainbow.js",
+      "require": "./dist/rainbow.umd.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "dev": "vite build --watch",
+    "build": "vite build && tsgo --emitDeclarationOnly",
+    "typecheck": "tsgo --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.14",
+    "@vitejs/plugin-vue": "^6.0.4",
+    "fast-check": "^4.5.3",
+    "vite": "^6.0.0",
+    "vitest": "^2.0.0",
+    "vue": "^3.5.29"
+  }
+}