@zeix/cause-effect 0.14.2 → 0.15.0

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

package/index.ts

@@ -1,6 +1,6 @@
 /**
  * @name Cause & Effect
- * @version 0.14.2
+ * @version 0.15.0
  * @author Esther Brunner
  */
 
@@ -9,9 +9,13 @@ 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 } 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,7 +29,6 @@ export {
 	watch,
 } from './src/scheduler'
 export {
-	isComputedCallback,
 	isSignal,
 	type MaybeSignal,
 	type Signal,
@@ -34,4 +37,20 @@ export {
 	UNSET,
 } 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,
+	toError,
+} from './src/util'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zeix/cause-effect",
-	"version": "0.14.2",
+	"version": "0.15.0",
 	"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