@zeix/cause-effect 0.14.2 → 0.15.1

package/index.dev.js

@@ -88,8 +88,20 @@ var enqueue = (fn, dedupe) => new Promise((resolve, reject) => {
 });
 
 // src/util.ts
-var isFunction = (value) => typeof value === "function";
+var isString = (value) => typeof value === "string";
+var isNumber = (value) => typeof value === "number";
+var isFunction = (fn) => typeof fn === "function";
+var isAsyncFunction = (fn) => isFunction(fn) && fn.constructor.name === "AsyncFunction";
 var isObjectOfType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
+var isRecord = (value) => isObjectOfType(value, "Object");
+var validArrayIndexes = (keys) => {
+  if (!keys.length)
+    return null;
+  const indexes = keys.map((k) => isString(k) ? parseInt(k, 10) : isNumber(k) ? k : NaN);
+  return indexes.every((index) => Number.isFinite(index) && index >= 0) ? indexes.sort((a, b) => a - b) : null;
+};
+var hasMethod = (obj, methodName) => (methodName in obj) && isFunction(obj[methodName]);
+var isAbortError = (error) => error instanceof DOMException && error.name === "AbortError";
 var toError = (reason) => reason instanceof Error ? reason : Error(String(reason));
 
 class CircularDependencyError extends Error {
@@ -111,7 +123,7 @@ var state = (initialValue) => {
       return value;
     },
     set: (v) => {
-      if (Object.is(value, v))
+      if (isEqual(value, v))
         return;
       value = v;
       notify(watchers);
@@ -126,10 +138,323 @@ var state = (initialValue) => {
 };
 var isState = (value) => isObjectOfType(value, TYPE_STATE);
 
+// src/effect.ts
+var effect = (callback) => {
+  const isAsync = isAsyncFunction(callback);
+  let running = false;
+  let controller;
+  const run = watch(() => observe(() => {
+    if (running)
+      throw new CircularDependencyError("effect");
+    running = true;
+    controller?.abort();
+    controller = undefined;
+    let cleanup;
+    try {
+      if (isAsync) {
+        controller = new AbortController;
+        const currentController = controller;
+        callback(controller.signal).then((cleanup2) => {
+          if (isFunction(cleanup2) && controller === currentController)
+            run.off(cleanup2);
+        }).catch((error) => {
+          if (!isAbortError(error))
+            console.error("Async effect error:", error);
+        });
+      } else {
+        cleanup = callback();
+        if (isFunction(cleanup))
+          run.off(cleanup);
+      }
+    } catch (error) {
+      if (!isAbortError(error))
+        console.error("Effect callback error:", error);
+    }
+    running = false;
+  }, run));
+  run();
+  return () => {
+    controller?.abort();
+    run.cleanup();
+  };
+};
+
+// src/store.ts
+var TYPE_STORE = "Store";
+var store = (initialValue) => {
+  const watchers = new Set;
+  const eventTarget = new EventTarget;
+  const signals = new Map;
+  const cleanups = new Map;
+  const size = state(0);
+  const current = () => {
+    const keys = Array.from(signals.keys());
+    const arrayIndexes = validArrayIndexes(keys);
+    if (arrayIndexes)
+      return arrayIndexes.map((index) => signals.get(String(index))?.get());
+    const record = {};
+    for (const [key, signal] of signals) {
+      record[key] = signal.get();
+    }
+    return record;
+  };
+  const emit = (type, detail) => eventTarget.dispatchEvent(new CustomEvent(type, { detail }));
+  const addProperty = (key, value) => {
+    const stringKey = String(key);
+    const signal = toMutableSignal(value);
+    signals.set(stringKey, signal);
+    const cleanup = effect(() => {
+      const currentValue = signal.get();
+      if (currentValue != null)
+        emit("store-change", { [key]: currentValue });
+    });
+    cleanups.set(stringKey, cleanup);
+  };
+  const removeProperty = (key) => {
+    const stringKey = String(key);
+    signals.delete(stringKey);
+    const cleanup = cleanups.get(stringKey);
+    if (cleanup)
+      cleanup();
+    cleanups.delete(stringKey);
+  };
+  const reconcile = (oldValue, newValue) => {
+    const changes = diff(oldValue, newValue);
+    batch(() => {
+      if (Object.keys(changes.add).length) {
+        for (const key in changes.add) {
+          const value = changes.add[key];
+          if (value != null)
+            addProperty(key, value);
+        }
+        emit("store-add", changes.add);
+      }
+      if (Object.keys(changes.change).length) {
+        for (const key in changes.change) {
+          const signal = signals.get(key);
+          const value = changes.change[key];
+          if (signal && value != null && hasMethod(signal, "set"))
+            signal.set(value);
+        }
+        emit("store-change", changes.change);
+      }
+      if (Object.keys(changes.remove).length) {
+        for (const key in changes.remove) {
+          removeProperty(key);
+        }
+        emit("store-remove", changes.remove);
+      }
+      size.set(signals.size);
+    });
+    return changes.changed;
+  };
+  reconcile({}, initialValue);
+  setTimeout(() => {
+    const initialAdditionsEvent = new CustomEvent("store-add", {
+      detail: initialValue
+    });
+    eventTarget.dispatchEvent(initialAdditionsEvent);
+  }, 0);
+  const storeProps = [
+    "add",
+    "get",
+    "remove",
+    "set",
+    "update",
+    "addEventListener",
+    "removeEventListener",
+    "dispatchEvent",
+    "size"
+  ];
+  return new Proxy({}, {
+    get(_target, prop) {
+      switch (prop) {
+        case "add":
+          return (k, v) => {
+            if (!signals.has(k)) {
+              addProperty(k, v);
+              notify(watchers);
+              emit("store-add", {
+                [k]: v
+              });
+              size.set(signals.size);
+            }
+          };
+        case "get":
+          return () => {
+            subscribe(watchers);
+            return current();
+          };
+        case "remove":
+          return (k) => {
+            if (signals.has(k)) {
+              removeProperty(k);
+              notify(watchers);
+              emit("store-remove", { [k]: UNSET });
+              size.set(signals.size);
+            }
+          };
+        case "set":
+          return (v) => {
+            if (reconcile(current(), v)) {
+              notify(watchers);
+              if (UNSET === v)
+                watchers.clear();
+            }
+          };
+        case "update":
+          return (fn) => {
+            const oldValue = current();
+            const newValue = fn(oldValue);
+            if (reconcile(oldValue, newValue)) {
+              notify(watchers);
+              if (UNSET === newValue)
+                watchers.clear();
+            }
+          };
+        case "addEventListener":
+          return eventTarget.addEventListener.bind(eventTarget);
+        case "removeEventListener":
+          return eventTarget.removeEventListener.bind(eventTarget);
+        case "dispatchEvent":
+          return eventTarget.dispatchEvent.bind(eventTarget);
+        case "size":
+          return size;
+      }
+      if (prop === Symbol.toStringTag)
+        return TYPE_STORE;
+      if (prop === Symbol.iterator) {
+        return function* () {
+          for (const [key, signal] of signals) {
+            yield [key, signal];
+          }
+        };
+      }
+      return signals.get(String(prop));
+    },
+    has(_target, prop) {
+      const key = String(prop);
+      return signals.has(key) || storeProps.includes(key) || prop === Symbol.toStringTag || prop === Symbol.iterator;
+    },
+    ownKeys() {
+      return Array.from(signals.keys()).map((key) => String(key));
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const signal = signals.get(String(prop));
+      return signal ? {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: signal
+      } : undefined;
+    }
+  });
+};
+var isStore = (value) => isObjectOfType(value, TYPE_STORE);
+
 // src/signal.ts
 var UNSET = Symbol();
-var isSignal = (value) => isState(value) || isComputed(value);
-var toSignal = (value) => isSignal(value) ? value : isComputedCallback(value) ? computed(value) : state(value);
+var isSignal = (value) => isState(value) || isComputed(value) || isStore(value);
+function toSignal(value) {
+  if (isSignal(value))
+    return value;
+  if (isComputedCallback(value))
+    return computed(value);
+  if (Array.isArray(value))
+    return store(value);
+  if (Array.isArray(value) || isRecord(value))
+    return store(value);
+  return state(value);
+}
+function toMutableSignal(value) {
+  if (isState(value) || isStore(value))
+    return value;
+  if (Array.isArray(value))
+    return store(value);
+  if (isRecord(value))
+    return store(value);
+  return state(value);
+}
+
+// src/diff.ts
+var isEqual = (a, b, visited) => {
+  if (Object.is(a, b))
+    return true;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object" || a === null || b === null)
+    return false;
+  if (!visited)
+    visited = new WeakSet;
+  if (visited.has(a) || visited.has(b))
+    throw new CircularDependencyError("isEqual");
+  visited.add(a);
+  visited.add(b);
+  try {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length)
+        return false;
+      for (let i = 0;i < a.length; i++) {
+        if (!isEqual(a[i], b[i], visited))
+          return false;
+      }
+      return true;
+    }
+    if (Array.isArray(a) !== Array.isArray(b))
+      return false;
+    if (isRecord(a) && isRecord(b)) {
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length)
+        return false;
+      for (const key of aKeys) {
+        if (!(key in b))
+          return false;
+        if (!isEqual(a[key], b[key], visited))
+          return false;
+      }
+      return true;
+    }
+    return false;
+  } finally {
+    visited.delete(a);
+    visited.delete(b);
+  }
+};
+var diff = (oldObj, newObj) => {
+  const visited = new WeakSet;
+  const diffRecords = (oldRecord, newRecord) => {
+    const add = {};
+    const change = {};
+    const remove = {};
+    const oldKeys = Object.keys(oldRecord);
+    const newKeys = Object.keys(newRecord);
+    const allKeys = new Set([...oldKeys, ...newKeys]);
+    for (const key of allKeys) {
+      const oldHas = key in oldRecord;
+      const newHas = key in newRecord;
+      if (!oldHas && newHas) {
+        add[key] = newRecord[key];
+        continue;
+      } else if (oldHas && !newHas) {
+        remove[key] = UNSET;
+        continue;
+      }
+      const oldValue = oldRecord[key];
+      const newValue = newRecord[key];
+      if (!isEqual(oldValue, newValue, visited))
+        change[key] = newValue;
+    }
+    const changed = Object.keys(add).length > 0 || Object.keys(change).length > 0 || Object.keys(remove).length > 0;
+    return {
+      changed,
+      add,
+      change,
+      remove
+    };
+  };
+  return diffRecords(oldObj, newObj);
+};
 
 // src/computed.ts
 var TYPE_COMPUTED = "Computed";
@@ -142,7 +467,7 @@ var computed = (fn) => {
   let changed = false;
   let computing = false;
   const ok = (v) => {
-    if (!Object.is(v, value)) {
+    if (!isEqual(v, value)) {
       value = v;
       changed = true;
     }
@@ -169,17 +494,20 @@ var computed = (fn) => {
   };
   const mark = watch(() => {
     dirty = true;
-    controller?.abort("Aborted because source signal changed");
+    controller?.abort();
     if (watchers.size)
       notify(watchers);
     else
       mark.cleanup();
   });
+  mark.off(() => {
+    controller?.abort();
+  });
   const compute = () => observe(() => {
     if (computing)
       throw new CircularDependencyError("computed");
     changed = false;
-    if (isFunction(fn) && fn.constructor.name === "AsyncFunction") {
+    if (isAsyncFunction(fn)) {
       if (controller)
         return value;
       controller = new AbortController;
@@ -196,7 +524,7 @@ var computed = (fn) => {
     try {
       result = controller ? fn(controller.signal) : fn();
     } catch (e) {
-      if (e instanceof DOMException && e.name === "AbortError")
+      if (isAbortError(e))
         nil();
       else
         err(e);
@@ -227,67 +555,75 @@ var computed = (fn) => {
 };
 var isComputed = (value) => isObjectOfType(value, TYPE_COMPUTED);
 var isComputedCallback = (value) => isFunction(value) && value.length < 2;
-// src/effect.ts
-function effect(matcher) {
-  const {
-    signals,
-    ok,
-    err = (error) => {
-      console.error(error);
-    },
-    nil = () => {
-    }
-  } = isFunction(matcher) ? { signals: [], ok: matcher } : matcher;
-  let running = false;
-  const run = watch(() => observe(() => {
-    if (running)
-      throw new CircularDependencyError("effect");
-    running = true;
-    const errors = [];
-    let pending2 = false;
-    const values = signals.map((signal) => {
-      try {
-        const value = signal.get();
-        if (value === UNSET)
-          pending2 = true;
-        return value;
-      } catch (e) {
-        errors.push(toError(e));
-        return UNSET;
-      }
-    });
-    let cleanup;
+// src/match.ts
+function match(result, handlers) {
+  try {
+    if (result.pending)
+      handlers.nil?.();
+    else if (result.errors)
+      handlers.err?.(result.errors);
+    else
+      handlers.ok?.(result.values);
+  } catch (error) {
+    if (handlers.err && (!result.errors || !result.errors.includes(toError(error))))
+      handlers.err(result.errors ? [...result.errors, toError(error)] : [toError(error)]);
+    else
+      throw error;
+  }
+}
+// src/resolve.ts
+function resolve(signals) {
+  const errors = [];
+  let pending2 = false;
+  const values = {};
+  for (const [key, signal] of Object.entries(signals)) {
     try {
-      cleanup = pending2 ? nil() : errors.length ? err(...errors) : ok(...values);
+      const value = signal.get();
+      if (value === UNSET)
+        pending2 = true;
+      else
+        values[key] = value;
     } catch (e) {
-      cleanup = err(toError(e));
-    } finally {
-      if (isFunction(cleanup))
-        run.off(cleanup);
+      errors.push(toError(e));
     }
-    running = false;
-  }, run));
-  run();
-  return () => run.cleanup();
+  }
+  if (pending2)
+    return { ok: false, pending: true };
+  if (errors.length > 0)
+    return { ok: false, errors };
+  return { ok: true, values };
 }
 export {
   watch,
   toSignal,
+  toMutableSignal,
+  toError,
   subscribe,
+  store,
   state,
+  resolve,
   observe,
   notify,
+  match,
+  isString,
+  isStore,
   isState,
   isSignal,
+  isNumber,
   isFunction,
+  isEqual,
   isComputedCallback,
   isComputed,
+  isAsyncFunction,
+  isAbortError,
   flush,
   enqueue,
   effect,
+  diff,
   computed,
   batch,
   UNSET,
+  TYPE_STORE,
   TYPE_STATE,
   TYPE_COMPUTED,
   CircularDependencyError

package/index.js

@@ -1 +1 @@
-var V,M=new Set,U=0,k=new Map,D,f=()=>{D=void 0;let $=Array.from(k.values());k.clear();for(let B of $)B()},d=()=>{if(D)cancelAnimationFrame(D);D=requestAnimationFrame(f)};queueMicrotask(f);var Y=($)=>{let B=new Set,W=$;return W.off=(z)=>{B.add(z)},W.cleanup=()=>{for(let z of B)z();B.clear()},W},I=($)=>{if(V&&!$.has(V)){let B=V;$.add(B),V.off(()=>{$.delete(B)})}},F=($)=>{for(let B of $)if(U)M.add(B);else B()},N=()=>{while(M.size){let $=Array.from(M);M.clear();for(let B of $)B()}},h=($)=>{U++;try{$()}finally{N(),U--}},O=($,B)=>{let W=V;V=B;try{$()}finally{V=W}},v=($,B)=>new Promise((W,z)=>{k.set(B||Symbol(),()=>{try{W($())}catch(G){z(G)}}),d()});var j=($)=>typeof $==="function",P=($,B)=>Object.prototype.toString.call($)===`[object ${B}]`,C=($)=>$ instanceof Error?$:Error(String($));class R extends Error{constructor($){super(`Circular dependency in ${$} detected`);this.name="CircularDependencyError"}}var _="State",S=($)=>{let B=new Set,W=$,z={[Symbol.toStringTag]:_,get:()=>{return I(B),W},set:(G)=>{if(Object.is(W,G))return;if(W=G,F(B),K===W)B.clear()},update:(G)=>{z.set(G(W))}};return z},T=($)=>P($,_);var K=Symbol(),p=($)=>T($)||b($),o=($)=>p($)?$:g($)?E($):S($);var m="Computed",E=($)=>{let B=new Set,W=K,z,G,X=!0,L=!1,J=!1,x=(H)=>{if(!Object.is(H,W))W=H,L=!0;z=void 0,X=!1},q=()=>{L=K!==W,W=K,z=void 0},Z=(H)=>{let Q=C(H);L=!z||Q.name!==z.name||Q.message!==z.message,W=K,z=Q},A=(H)=>(Q)=>{if(J=!1,G=void 0,H(Q),L)F(B)},y=Y(()=>{if(X=!0,G?.abort("Aborted because source signal changed"),B.size)F(B);else y.cleanup()}),w=()=>O(()=>{if(J)throw new R("computed");if(L=!1,j($)&&$.constructor.name==="AsyncFunction"){if(G)return W;G=new AbortController,G.signal.addEventListener("abort",()=>{J=!1,G=void 0,w()},{once:!0})}let H;J=!0;try{H=G?$(G.signal):$()}catch(Q){if(Q instanceof DOMException&&Q.name==="AbortError")q();else Z(Q);J=!1;return}if(H instanceof Promise)H.then(A(x),A(Z));else if(H==null||K===H)q();else x(H);J=!1},y);return{[Symbol.toStringTag]:m,get:()=>{if(I(B),N(),X)w();if(z)throw z;return W}}},b=($)=>P($,m),g=($)=>j($)&&$.length<2;function s($){let{signals:B,ok:W,err:z=(J)=>{console.error(J)},nil:G=()=>{}}=j($)?{signals:[],ok:$}:$,X=!1,L=Y(()=>O(()=>{if(X)throw new R("effect");X=!0;let J=[],x=!1,q=B.map((A)=>{try{let y=A.get();if(y===K)x=!0;return y}catch(y){return J.push(C(y)),K}}),Z;try{Z=x?G():J.length?z(...J):W(...q)}catch(A){Z=z(C(A))}finally{if(j(Z))L.off(Z)}X=!1},L));return L(),()=>L.cleanup()}export{Y as watch,o as toSignal,I as subscribe,S as state,O as observe,F as notify,T as isState,p as isSignal,j as isFunction,g as isComputedCallback,b as isComputed,N as flush,v as enqueue,s as effect,E as computed,h as batch,K as UNSET,_ as TYPE_STATE,m as TYPE_COMPUTED,R as CircularDependencyError};
+var q,f=new Set,p=0,h=new Map,k,r=()=>{k=void 0;let $=Array.from(h.values());h.clear();for(let B of $)B()},F$=()=>{if(k)cancelAnimationFrame(k);k=requestAnimationFrame(r)};queueMicrotask(r);var E=($)=>{let B=new Set,W=$;return W.off=(F)=>{B.add(F)},W.cleanup=()=>{for(let F of B)F();B.clear()},W},O=($)=>{if(q&&!$.has(q)){let B=q;$.add(B),q.off(()=>{$.delete(B)})}},C=($)=>{for(let B of $)if(p)f.add(B);else B()},w=()=>{while(f.size){let $=Array.from(f);f.clear();for(let B of $)B()}},v=($)=>{p++;try{$()}finally{w(),p--}},T=($,B)=>{let W=q;q=B;try{$()}finally{q=W}},G$=($,B)=>new Promise((W,F)=>{h.set(B||Symbol(),()=>{try{W($())}catch(Q){F(Q)}}),F$()});var a=($)=>typeof $==="string",e=($)=>typeof $==="number",D=($)=>typeof $==="function",y=($)=>D($)&&$.constructor.name==="AsyncFunction",P=($,B)=>Object.prototype.toString.call($)===`[object ${B}]`,R=($)=>P($,"Object"),$$=($)=>{if(!$.length)return null;let B=$.map((W)=>a(W)?parseInt(W,10):e(W)?W:NaN);return B.every((W)=>Number.isFinite(W)&&W>=0)?B.sort((W,F)=>W-F):null},B$=($,B)=>(B in $)&&D($[B]),V=($)=>$ instanceof DOMException&&$.name==="AbortError",Y=($)=>$ instanceof Error?$:Error(String($));class I extends Error{constructor($){super(`Circular dependency in ${$} detected`);this.name="CircularDependencyError"}}var d="State",S=($)=>{let B=new Set,W=$,F={[Symbol.toStringTag]:d,get:()=>{return O(B),W},set:(Q)=>{if(K(W,Q))return;if(W=Q,C(B),z===W)B.clear()},update:(Q)=>{F.set(Q(W))}};return F},b=($)=>P($,d);var o=($)=>{let B=y($),W=!1,F,Q=E(()=>T(()=>{if(W)throw new I("effect");W=!0,F?.abort(),F=void 0;let Z;try{if(B){F=new AbortController;let A=F;$(F.signal).then((H)=>{if(D(H)&&F===A)Q.off(H)}).catch((H)=>{if(!V(H))console.error("Async effect error:",H)})}else if(Z=$(),D(Z))Q.off(Z)}catch(A){if(!V(A))console.error("Effect callback error:",A)}W=!1},Q));return Q(),()=>{F?.abort(),Q.cleanup()}};var c="Store",m=($)=>{let B=new Set,W=new EventTarget,F=new Map,Q=new Map,Z=S(0),A=()=>{let M=Array.from(F.keys()),L=$$(M);if(L)return L.map((J)=>F.get(String(J))?.get());let G={};for(let[J,X]of F)G[J]=X.get();return G},H=(M,L)=>W.dispatchEvent(new CustomEvent(M,{detail:L})),x=(M,L)=>{let G=String(M),J=n(L);F.set(G,J);let X=o(()=>{let j=J.get();if(j!=null)H("store-change",{[M]:j})});Q.set(G,X)},U=(M)=>{let L=String(M);F.delete(L);let G=Q.get(L);if(G)G();Q.delete(L)},N=(M,L)=>{let G=u(M,L);return v(()=>{if(Object.keys(G.add).length){for(let J in G.add){let X=G.add[J];if(X!=null)x(J,X)}H("store-add",G.add)}if(Object.keys(G.change).length){for(let J in G.change){let X=F.get(J),j=G.change[J];if(X&&j!=null&&B$(X,"set"))X.set(j)}H("store-change",G.change)}if(Object.keys(G.remove).length){for(let J in G.remove)U(J);H("store-remove",G.remove)}Z.set(F.size)}),G.changed};N({},$),setTimeout(()=>{let M=new CustomEvent("store-add",{detail:$});W.dispatchEvent(M)},0);let _=["add","get","remove","set","update","addEventListener","removeEventListener","dispatchEvent","size"];return new Proxy({},{get(M,L){switch(L){case"add":return(G,J)=>{if(!F.has(G))x(G,J),C(B),H("store-add",{[G]:J}),Z.set(F.size)};case"get":return()=>{return O(B),A()};case"remove":return(G)=>{if(F.has(G))U(G),C(B),H("store-remove",{[G]:z}),Z.set(F.size)};case"set":return(G)=>{if(N(A(),G)){if(C(B),z===G)B.clear()}};case"update":return(G)=>{let J=A(),X=G(J);if(N(J,X)){if(C(B),z===X)B.clear()}};case"addEventListener":return W.addEventListener.bind(W);case"removeEventListener":return W.removeEventListener.bind(W);case"dispatchEvent":return W.dispatchEvent.bind(W);case"size":return Z}if(L===Symbol.toStringTag)return c;if(L===Symbol.iterator)return function*(){for(let[G,J]of F)yield[G,J]};return F.get(String(L))},has(M,L){let G=String(L);return F.has(G)||_.includes(G)||L===Symbol.toStringTag||L===Symbol.iterator},ownKeys(){return Array.from(F.keys()).map((M)=>String(M))},getOwnPropertyDescriptor(M,L){let G=F.get(String(L));return G?{enumerable:!0,configurable:!0,writable:!0,value:G}:void 0}})},g=($)=>P($,c);var z=Symbol(),W$=($)=>b($)||t($)||g($);function J$($){if(W$($))return $;if(s($))return i($);if(Array.isArray($))return m($);if(Array.isArray($)||R($))return m($);return S($)}function n($){if(b($)||g($))return $;if(Array.isArray($))return m($);if(R($))return m($);return S($)}var K=($,B,W)=>{if(Object.is($,B))return!0;if(typeof $!==typeof B)return!1;if(typeof $!=="object"||$===null||B===null)return!1;if(!W)W=new WeakSet;if(W.has($)||W.has(B))throw new I("isEqual");W.add($),W.add(B);try{if(Array.isArray($)&&Array.isArray(B)){if($.length!==B.length)return!1;for(let F=0;F<$.length;F++)if(!K($[F],B[F],W))return!1;return!0}if(Array.isArray($)!==Array.isArray(B))return!1;if(R($)&&R(B)){let F=Object.keys($),Q=Object.keys(B);if(F.length!==Q.length)return!1;for(let Z of F){if(!(Z in B))return!1;if(!K($[Z],B[Z],W))return!1}return!0}return!1}finally{W.delete($),W.delete(B)}},u=($,B)=>{let W=new WeakSet;return((Q,Z)=>{let A={},H={},x={},U=Object.keys(Q),N=Object.keys(Z),_=new Set([...U,...N]);for(let L of _){let G=L in Q,J=L in Z;if(!G&&J){A[L]=Z[L];continue}else if(G&&!J){x[L]=z;continue}let X=Q[L],j=Z[L];if(!K(X,j,W))H[L]=j}return{changed:Object.keys(A).length>0||Object.keys(H).length>0||Object.keys(x).length>0,add:A,change:H,remove:x}})($,B)};var l="Computed",i=($)=>{let B=new Set,W=z,F,Q,Z=!0,A=!1,H=!1,x=(J)=>{if(!K(J,W))W=J,A=!0;F=void 0,Z=!1},U=()=>{A=z!==W,W=z,F=void 0},N=(J)=>{let X=Y(J);A=!F||X.name!==F.name||X.message!==F.message,W=z,F=X},_=(J)=>(X)=>{if(H=!1,Q=void 0,J(X),A)C(B)},M=E(()=>{if(Z=!0,Q?.abort(),B.size)C(B);else M.cleanup()});M.off(()=>{Q?.abort()});let L=()=>T(()=>{if(H)throw new I("computed");if(A=!1,y($)){if(Q)return W;Q=new AbortController,Q.signal.addEventListener("abort",()=>{H=!1,Q=void 0,L()},{once:!0})}let J;H=!0;try{J=Q?$(Q.signal):$()}catch(X){if(V(X))U();else N(X);H=!1;return}if(J instanceof Promise)J.then(_(x),_(N));else if(J==null||z===J)U();else x(J);H=!1},M);return{[Symbol.toStringTag]:l,get:()=>{if(O(B),w(),Z)L();if(F)throw F;return W}}},t=($)=>P($,l),s=($)=>D($)&&$.length<2;function L$($,B){try{if($.pending)B.nil?.();else if($.errors)B.err?.($.errors);else B.ok?.($.values)}catch(W){if(B.err&&(!$.errors||!$.errors.includes(Y(W))))B.err($.errors?[...$.errors,Y(W)]:[Y(W)]);else throw W}}function Q$($){let B=[],W=!1,F={};for(let[Q,Z]of Object.entries($))try{let A=Z.get();if(A===z)W=!0;else F[Q]=A}catch(A){B.push(Y(A))}if(W)return{ok:!1,pending:!0};if(B.length>0)return{ok:!1,errors:B};return{ok:!0,values:F}}export{E as watch,J$ as toSignal,n as toMutableSignal,Y as toError,O as subscribe,m as store,S as state,Q$ as resolve,T as observe,C as notify,L$ as match,a as isString,g as isStore,b as isState,W$ as isSignal,e as isNumber,D as isFunction,K as isEqual,s as isComputedCallback,t as isComputed,y as isAsyncFunction,V as isAbortError,w as flush,G$ as enqueue,o as effect,u as diff,i as computed,v as batch,z as UNSET,c as TYPE_STORE,d as TYPE_STATE,l as TYPE_COMPUTED,I as CircularDependencyError};

package/index.ts

@@ -1,6 +1,6 @@
 /**
  * @name Cause & Effect
- * @version 0.14.2
+ * @version 0.15.1
  * @author Esther Brunner
  */
 
@@ -9,9 +9,19 @@ export {
 	type ComputedCallback,
 	computed,
 	isComputed,
+	isComputedCallback,
 	TYPE_COMPUTED,
 } from './src/computed'
-export { type EffectMatcher, effect } from './src/effect'
+export {
+	type DiffResult,
+	diff,
+	isEqual,
+	type UnknownRecord,
+	type UnknownRecordOrArray,
+} from './src/diff'
+export { type EffectCallback, effect, type MaybeCleanup } from './src/effect'
+export { type MatchHandlers, match } from './src/match'
+export { type ResolveResult, resolve } from './src/resolve'
 export {
 	batch,
 	type Cleanup,
@@ -25,13 +35,32 @@ export {
 	watch,
 } from './src/scheduler'
 export {
-	isComputedCallback,
 	isSignal,
 	type MaybeSignal,
 	type Signal,
 	type SignalValues,
+	toMutableSignal,
 	toSignal,
 	UNSET,
+	type UnknownSignalRecord,
 } from './src/signal'
 export { isState, type State, state, TYPE_STATE } from './src/state'
-export { CircularDependencyError, isFunction } from './src/util'
+export {
+	isStore,
+	type Store,
+	type StoreAddEvent,
+	type StoreChangeEvent,
+	type StoreEventMap,
+	type StoreRemoveEvent,
+	store,
+	TYPE_STORE,
+} from './src/store'
+export {
+	CircularDependencyError,
+	isAbortError,
+	isAsyncFunction,
+	isFunction,
+	isNumber,
+	isString,
+	toError,
+} from './src/util'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zeix/cause-effect",
-	"version": "0.14.2",
+	"version": "0.15.1",
 	"author": "Esther Brunner",
 	"main": "index.js",
 	"module": "index.ts",
@@ -29,5 +29,5 @@
 		"lint": "bunx biome lint --write"
 	},
 	"type": "module",
-	"types": "index.d.ts"
+	"types": "types/index.d.ts"
 }

package/src/computed.ts

@@ -1,3 +1,4 @@
+import { isEqual } from './diff'
 import {
 	flush,
 	notify,
@@ -9,6 +10,8 @@ import {
 import { UNSET } from './signal'
 import {
 	CircularDependencyError,
+	isAbortError,
+	isAsyncFunction,
 	isFunction,
 	isObjectOfType,
 	toError,
@@ -50,7 +53,7 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 
 	// Functions to update internal state
 	const ok = (v: T): undefined => {
-		if (!Object.is(v, value)) {
+		if (!isEqual(v, value)) {
 			value = v
 			changed = true
 		}
@@ -83,25 +86,31 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 	// Own watcher: called when notified from sources (push)
 	const mark = watch(() => {
 		dirty = true
-		controller?.abort('Aborted because source signal changed')
+		controller?.abort()
 		if (watchers.size) notify(watchers)
 		else mark.cleanup()
 	})
+	mark.off(() => {
+		controller?.abort()
+	})
 
 	// Called when requested by dependencies (pull)
 	const compute = () =>
 		observe(() => {
 			if (computing) throw new CircularDependencyError('computed')
 			changed = false
-			if (isFunction(fn) && fn.constructor.name === 'AsyncFunction') {
-				if (controller) return value // return current value until promise resolves
+			if (isAsyncFunction(fn)) {
+				// Return current value until promise resolves
+				if (controller) return value
 				controller = new AbortController()
 				controller.signal.addEventListener(
 					'abort',
 					() => {
 						computing = false
 						controller = undefined
-						compute() // retry
+
+						// Retry computation with updated state
+						compute()
 					},
 					{
 						once: true,
@@ -113,7 +122,7 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 			try {
 				result = controller ? fn(controller.signal) : (fn as () => T)()
 			} catch (e) {
-				if (e instanceof DOMException && e.name === 'AbortError') nil()
+				if (isAbortError(e)) nil()
 				else err(e)
 				computing = false
 				return