@zeix/cause-effect 0.15.1 → 0.16.0

package/index.js

@@ -1 +1 @@
-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};
+class W extends Error{constructor($){super(`Circular dependency detected in ${$}`);this.name="CircularDependencyError"}}class P extends TypeError{constructor($,x){super(`Invalid ${$} callback ${x}`);this.name="InvalidCallbackError"}}class n extends TypeError{constructor($,x){super(`Invalid signal value ${x} in ${$}`);this.name="InvalidSignalValueError"}}class L extends TypeError{constructor($){super(`Nullish signal values are not allowed in ${$}`);this.name="NullishSignalValueError"}}class u extends Error{constructor($,x){super(`Could not add store key "${$}" with value ${x} because it already exists`);this.name="StoreKeyExistsError"}}class c extends RangeError{constructor($){super(`Could not remove store index ${String($)} because it is out of range`);this.name="StoreKeyRangeError"}}class t extends Error{constructor($,x){super(`Could not set store key "${$}" to ${x} because it is readonly`);this.name="StoreKeyReadonlyError"}}var K=Symbol(),x$=($)=>typeof $==="string",H$=($)=>typeof $==="number",p=($)=>typeof $==="symbol",Y=($)=>typeof $==="function",d=($)=>Y($)&&$.constructor.name==="AsyncFunction",E=($,x)=>Object.prototype.toString.call($)===`[object ${x}]`,A=($)=>E($,"Object"),s=($)=>A($)||Array.isArray($),K$=($)=>{if(!$.length)return null;let x=$.map((G)=>x$(G)?parseInt(G,10):H$(G)?G:NaN);return x.every((G)=>Number.isFinite(G)&&G>=0)?x.sort((G,J)=>G-J):null};var g=($)=>$ instanceof DOMException&&$.name==="AbortError",_=($)=>$ instanceof Error?$:Error(String($));var i=($)=>{let x=K$(Object.keys($));if(x===null)return $;let G=[];for(let J of x)G.push($[String(J)]);return G},U=($)=>x$($)?`"${$}"`:!!$&&typeof $==="object"?JSON.stringify($):String($);var f=($,x,G)=>{if(Object.is($,x))return!0;if(typeof $!==typeof x)return!1;if(typeof $!=="object"||$===null||x===null)return!1;if(!G)G=new WeakSet;if(G.has($)||G.has(x))throw new W("isEqual");G.add($),G.add(x);try{if(Array.isArray($)&&Array.isArray(x)){if($.length!==x.length)return!1;for(let J=0;J<$.length;J++)if(!f($[J],x[J],G))return!1;return!0}if(Array.isArray($)!==Array.isArray(x))return!1;if(A($)&&A(x)){let J=Object.keys($),Q=Object.keys(x);if(J.length!==Q.length)return!1;for(let M of J){if(!(M in x))return!1;if(!f($[M],x[M],G))return!1}return!0}return!1}finally{G.delete($),G.delete(x)}},R$=($,x)=>{let G=s($),J=s(x);if(!G||!J){let q=!Object.is($,x);return{changed:q,add:q&&J?x:{},change:{},remove:q&&G?$:{}}}let Q=new WeakSet,M={},I={},C={},D=Object.keys($),j=Object.keys(x),O=new Set([...D,...j]);for(let q of O){let N=q in $,T=q in x;if(!N&&T){M[q]=x[q];continue}else if(N&&!T){C[q]=K;continue}let B=$[q],R=x[q];if(!f(B,R,Q))I[q]=R}return{changed:Object.keys(M).length>0||Object.keys(I).length>0||Object.keys(C).length>0,add:M,change:I,remove:C}};var w,r=new Set,B$=0,V=($)=>{let x=new Set,G=$;return G.unwatch=(J)=>{x.add(J)},G.cleanup=()=>{for(let J of x)J();x.clear()},G},m=($)=>{if(w&&!$.has(w)){let x=w;x.unwatch(()=>{$.delete(x)}),$.add(x)}},F=($)=>{for(let x of $)if(B$)r.add(x);else x()},l=()=>{while(r.size){let $=Array.from(r);r.clear();for(let x of $)x()}},J$=($)=>{B$++;try{$()}finally{l(),B$--}},y=($,x)=>{let G=w;w=x;try{$()}finally{w=G}};var G$="Computed",M$=($,x=K)=>{if(!a($))throw new P("computed",U($));if(x==null)throw new L("computed");let G=new Set,J=x,Q,M,I=!0,C=!1,D=!1,j=(B)=>{if(!f(B,J))J=B,C=!0;Q=void 0,I=!1},O=()=>{C=K!==J,J=K,Q=void 0},S=(B)=>{let R=_(B);C=!Q||R.name!==Q.name||R.message!==Q.message,J=K,Q=R},q=(B)=>(R)=>{if(D=!1,M=void 0,B(R),C)F(G)},N=V(()=>{if(I=!0,M?.abort(),G.size)F(G);else N.cleanup()});N.unwatch(()=>{M?.abort()});let T=()=>y(()=>{if(D)throw new W("computed");if(C=!1,d($)){if(M)return J;M=new AbortController,M.signal.addEventListener("abort",()=>{D=!1,M=void 0,T()},{once:!0})}let B;D=!0;try{B=M?$(J,M.signal):$(J)}catch(R){if(g(R))O();else S(R);D=!1;return}if(B instanceof Promise)B.then(q(j),q(S));else if(B==null||K===B)O();else j(B);D=!1},N);return{[Symbol.toStringTag]:G$,get:()=>{if(m(G),l(),I)T();if(Q)throw Q;return J}}},o=($)=>E($,G$),a=($)=>Y($)&&$.length<3;var q$=($)=>{if(!Y($)||$.length>1)throw new P("effect",U($));let x=d($),G=!1,J,Q=V(()=>y(()=>{if(G)throw new W("effect");G=!0,J?.abort(),J=void 0;let M;try{if(x){J=new AbortController;let I=J;$(J.signal).then((C)=>{if(Y(C)&&J===I)Q.unwatch(C)}).catch((C)=>{if(!g(C))console.error("Async effect error:",C)})}else if(M=$(),Y(M))Q.unwatch(M)}catch(I){if(!g(I))console.error("Effect callback error:",I)}G=!1},Q));return Q(),()=>{J?.abort(),Q.cleanup()}};function D$($,x){try{if($.pending)x.nil?.();else if($.errors)x.err?.($.errors);else if($.ok)x.ok($.values)}catch(G){if(x.err&&(!$.errors||!$.errors.includes(_(G))))x.err($.errors?[...$.errors,_(G)]:[_(G)]);else throw G}}function z$($){let x=[],G=!1,J={};for(let[Q,M]of Object.entries($))try{let I=M.get();if(I===K)G=!0;else J[Q]=I}catch(I){x.push(_(I))}if(G)return{ok:!1,pending:!0};if(x.length>0)return{ok:!1,errors:x};return{ok:!0,values:J}}var Q$="State",b=($)=>{if($==null)throw new L("state");let x=new Set,G=$,J={[Symbol.toStringTag]:Q$,get:()=>{return m(x),G},set:(Q)=>{if(Q==null)throw new L("state");if(f(G,Q))return;if(G=Q,F(x),K===G)x.clear()},update:(Q)=>{if(!Y(Q))throw new P("state update",U(Q));J.set(Q(G))}};return J},k=($)=>E($,Q$);var e="Store",$$=($)=>{if($==null)throw new L("store");let x=new Set,G={add:new Set,change:new Set,remove:new Set,sort:new Set},J=new Map,Q=new Map,M=Array.isArray($),I=b(0),C=()=>{let B={};for(let[R,X]of J)B[R]=X.get();return B},D=(B,R)=>{Object.freeze(R);for(let X of G[B])X(R)},j=()=>Array.from(J.keys()).map((B)=>Number(B)).filter((B)=>Number.isInteger(B)).sort((B,R)=>B-R),O=(B,R)=>{if(R==null)throw new L(`store for key "${B}"`);if(R===K)return!0;if(p(R)||Y(R)||o(R))throw new n(`store for key "${B}"`,U(R));return!0},S=(B,R,X=!1)=>{if(!O(B,R))return!1;let Z=k(R)||h(R)?R:A(R)||Array.isArray(R)?$$(R):b(R);J.set(B,Z);let H=V(()=>y(()=>{D("change",{[B]:Z.get()})},H));if(H(),Q.set(B,H),X)I.set(J.size),F(x),D("add",{[B]:R});return!0},q=(B,R=!1)=>{let X=J.delete(B);if(X){let Z=Q.get(B);if(Z)Z.cleanup();Q.delete(B)}if(R)I.set(J.size),F(x),D("remove",{[B]:K});return X},N=(B,R,X)=>{let Z=R$(B,R);return J$(()=>{if(Object.keys(Z.add).length){for(let H in Z.add){let z=Z.add[H]??K;S(H,z)}if(X)setTimeout(()=>{D("add",Z.add)},0);else D("add",Z.add)}if(Object.keys(Z.change).length){for(let H in Z.change){let z=Z.change[H];if(!O(H,z))continue;let v=J.get(H);if(X$(v))v.set(z);else throw new t(H,U(z))}D("change",Z.change)}if(Object.keys(Z.remove).length){for(let H in Z.remove)q(H);D("remove",Z.remove)}I.set(J.size)}),Z.changed};N({},$,!0);let T={add:M?(B)=>{let R=J.size,X=String(R);S(X,B,!0)}:(B,R)=>{if(!J.has(B))S(B,R,!0);else throw new u(B,U(R))},get:()=>{return m(x),i(C())},remove:M?(B)=>{let R=i(C()),X=J.size;if(!Array.isArray(R)||B<=-X||B>=X)throw new c(B);let Z=[...R];if(Z.splice(B,1),N(R,Z))F(x)}:(B)=>{if(J.has(B))q(B,!0)},set:(B)=>{if(N(C(),B)){if(F(x),K===B)x.clear()}},update:(B)=>{let R=C(),X=B(i(R));if(N(R,X)){if(F(x),K===X)x.clear()}},sort:(B)=>{let R=Array.from(J.entries()).map(([H,z])=>[H,z.get()]).sort(B?(H,z)=>B(H[1],z[1]):(H,z)=>String(H[1]).localeCompare(String(z[1]))),X=R.map(([H])=>String(H)),Z=new Map;R.forEach(([H],z)=>{let v=String(H),C$=M?String(z):String(H),Z$=J.get(v);if(Z$)Z.set(C$,Z$)}),J.clear(),Z.forEach((H,z)=>J.set(z,H)),F(x),D("sort",X)},on:(B,R)=>{return G[B].add(R),()=>G[B].delete(R)},size:I};return new Proxy({},{get(B,R){if(R===Symbol.toStringTag)return e;if(R===Symbol.isConcatSpreadable)return M;if(R===Symbol.iterator)return M?function*(){let X=j();for(let Z of X){let H=J.get(String(Z));if(H)yield H}}:function*(){for(let[X,Z]of J)yield[X,Z]};if(p(R))return;if(R in T)return T[R];if(R==="length"&&M)return m(x),I.get();return J.get(R)},has(B,R){let X=String(R);return X&&J.has(X)||Object.keys(T).includes(X)||R===Symbol.toStringTag||R===Symbol.iterator||R===Symbol.isConcatSpreadable||R==="length"&&M},ownKeys(){return M?j().map((B)=>String(B)).concat(["length"]):Array.from(J.keys()).map((B)=>String(B))},getOwnPropertyDescriptor(B,R){let X=(H)=>({enumerable:!1,configurable:!0,writable:!1,value:H});if(R==="length"&&M)return{enumerable:!0,configurable:!0,writable:!1,value:I.get()};if(R===Symbol.isConcatSpreadable)return X(M);if(R===Symbol.toStringTag)return X(e);if(p(R))return;if(Object.keys(T).includes(R))return X(T[R]);let Z=J.get(R);return Z?{enumerable:!0,configurable:!0,writable:!0,value:Z}:void 0}})},h=($)=>E($,e);var I$=($)=>k($)||o($)||h($),X$=($)=>k($)||h($);function F$($){if(I$($))return $;if(a($))return M$($);if(Array.isArray($)||A($))return $$($);return b($)}export{U as valueString,F$ as toSignal,_ as toError,m as subscribe,z$ as resolve,y as observe,F as notify,D$ as match,p as isSymbol,x$ as isString,h as isStore,k as isState,I$ as isSignal,s as isRecordOrArray,A as isRecord,H$ as isNumber,X$ as isMutableSignal,Y as isFunction,f as isEqual,a as isComputedCallback,o as isComputed,d as isAsyncFunction,g as isAbortError,l as flush,R$ as diff,V as createWatcher,$$ as createStore,b as createState,q$ as createEffect,M$ as createComputed,J$ as batch,K as UNSET,e as TYPE_STORE,Q$ as TYPE_STATE,G$ as TYPE_COMPUTED,t as StoreKeyReadonlyError,c as StoreKeyRangeError,u as StoreKeyExistsError,L as NullishSignalValueError,n as InvalidSignalValueError,P as InvalidCallbackError,W as CircularDependencyError};

package/index.ts

@@ -1,13 +1,13 @@
 /**
  * @name Cause & Effect
- * @version 0.15.1
+ * @version 0.16.0
  * @author Esther Brunner
  */
 
 export {
 	type Computed,
 	type ComputedCallback,
-	computed,
+	createComputed,
 	isComputed,
 	isComputedCallback,
 	TYPE_COMPUTED,
@@ -16,51 +16,62 @@ export {
 	type DiffResult,
 	diff,
 	isEqual,
+	type UnknownArray,
 	type UnknownRecord,
 	type UnknownRecordOrArray,
 } from './src/diff'
-export { type EffectCallback, effect, type MaybeCleanup } from './src/effect'
+export {
+	createEffect,
+	type EffectCallback,
+	type MaybeCleanup,
+} from './src/effect'
+export {
+	CircularDependencyError,
+	InvalidCallbackError,
+	InvalidSignalValueError,
+	NullishSignalValueError,
+	StoreKeyExistsError,
+	StoreKeyRangeError,
+	StoreKeyReadonlyError,
+} from './src/errors'
 export { type MatchHandlers, match } from './src/match'
 export { type ResolveResult, resolve } from './src/resolve'
 export {
-	batch,
-	type Cleanup,
-	enqueue,
-	flush,
-	notify,
-	observe,
-	subscribe,
-	type Updater,
-	type Watcher,
-	watch,
-} from './src/scheduler'
-export {
+	isMutableSignal,
 	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 { createState, isState, type State, TYPE_STATE } from './src/state'
 export {
+	createStore,
 	isStore,
 	type Store,
-	type StoreAddEvent,
-	type StoreChangeEvent,
-	type StoreEventMap,
-	type StoreRemoveEvent,
-	store,
+	type StoreChanges,
 	TYPE_STORE,
 } from './src/store'
 export {
-	CircularDependencyError,
+	batch,
+	type Cleanup,
+	createWatcher,
+	flush,
+	notify,
+	observe,
+	subscribe,
+	type Watcher,
+} from './src/system'
+export {
 	isAbortError,
 	isAsyncFunction,
 	isFunction,
 	isNumber,
+	isRecord,
+	isRecordOrArray,
 	isString,
+	isSymbol,
 	toError,
+	UNSET,
+	valueString,
 } from './src/util'

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zeix/cause-effect",
-	"version": "0.15.1",
+	"version": "0.16.0",
 	"author": "Esther Brunner",
 	"main": "index.js",
 	"module": "index.ts",

package/src/computed.ts

@@ -1,31 +1,36 @@
 import { isEqual } from './diff'
 import {
+	CircularDependencyError,
+	InvalidCallbackError,
+	NullishSignalValueError,
+} from './errors'
+import {
+	createWatcher,
 	flush,
 	notify,
 	observe,
 	subscribe,
 	type Watcher,
-	watch,
-} from './scheduler'
-import { UNSET } from './signal'
+} from './system'
 import {
-	CircularDependencyError,
 	isAbortError,
 	isAsyncFunction,
 	isFunction,
 	isObjectOfType,
 	toError,
+	UNSET,
+	valueString,
 } from './util'
 
 /* === Types === */
 
 type Computed<T extends {}> = {
-	[Symbol.toStringTag]: 'Computed'
+	readonly [Symbol.toStringTag]: 'Computed'
 	get(): T
 }
 type ComputedCallback<T extends {} & { then?: undefined }> =
-	| ((abort: AbortSignal) => Promise<T>)
-	| (() => T)
+	| ((oldValue: T, abort: AbortSignal) => Promise<T>)
+	| ((oldValue: T) => T)
 
 /* === Constants === */
 
@@ -37,14 +42,21 @@ const TYPE_COMPUTED = 'Computed'
  * Create a derived signal from existing signals
  *
  * @since 0.9.0
- * @param {ComputedCallback<T>} fn - computation callback function
+ * @param {ComputedCallback<T>} callback - Computation callback function
  * @returns {Computed<T>} - Computed signal
  */
-const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
+const createComputed = <T extends {}>(
+	callback: ComputedCallback<T>,
+	initialValue: T = UNSET,
+): Computed<T> => {
+	if (!isComputedCallback(callback))
+		throw new InvalidCallbackError('computed', valueString(callback))
+	if (initialValue == null) throw new NullishSignalValueError('computed')
+
 	const watchers: Set<Watcher> = new Set()
 
 	// Internal state
-	let value: T = UNSET
+	let value: T = initialValue
 	let error: Error | undefined
 	let controller: AbortController | undefined
 	let dirty = true
@@ -75,22 +87,22 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 		error = newError
 	}
 	const settle =
-		<T>(settleFn: (arg: T) => void) =>
+		<T>(fn: (arg: T) => void) =>
 		(arg: T) => {
 			computing = false
 			controller = undefined
-			settleFn(arg)
+			fn(arg)
 			if (changed) notify(watchers)
 		}
 
 	// Own watcher: called when notified from sources (push)
-	const mark = watch(() => {
+	const watcher = createWatcher(() => {
 		dirty = true
 		controller?.abort()
 		if (watchers.size) notify(watchers)
-		else mark.cleanup()
+		else watcher.cleanup()
 	})
-	mark.off(() => {
+	watcher.unwatch(() => {
 		controller?.abort()
 	})
 
@@ -99,7 +111,7 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 		observe(() => {
 			if (computing) throw new CircularDependencyError('computed')
 			changed = false
-			if (isAsyncFunction(fn)) {
+			if (isAsyncFunction(callback)) {
 				// Return current value until promise resolves
 				if (controller) return value
 				controller = new AbortController()
@@ -108,9 +120,7 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 					() => {
 						computing = false
 						controller = undefined
-
-						// Retry computation with updated state
-						compute()
+						compute() // Retry computation with updated state
 					},
 					{
 						once: true,
@@ -120,7 +130,9 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 			let result: T | Promise<T>
 			computing = true
 			try {
-				result = controller ? fn(controller.signal) : (fn as () => T)()
+				result = controller
+					? callback(value, controller.signal)
+					: (callback as (oldValue: T) => T)(value)
 			} catch (e) {
 				if (isAbortError(e)) nil()
 				else err(e)
@@ -131,16 +143,16 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 			else if (null == result || UNSET === result) nil()
 			else ok(result)
 			computing = false
-		}, mark)
+		}, watcher)
 
-	const c: Computed<T> = {
+	return {
 		[Symbol.toStringTag]: TYPE_COMPUTED,
 
 		/**
 		 * Get the current value of the computed
 		 *
 		 * @since 0.9.0
-		 * @returns {T} - current value of the computed
+		 * @returns {T} - Current value of the computed
 		 */
 		get: (): T => {
 			subscribe(watchers)
@@ -150,15 +162,14 @@ const computed = <T extends {}>(fn: ComputedCallback<T>): Computed<T> => {
 			return value
 		},
 	}
-	return c
 }
 
 /**
- * Check if a value is a computed state
+ * Check if a value is a computed signal
  *
  * @since 0.9.0
- * @param {unknown} value - value to check
- * @returns {boolean} - true if value is a computed state, false otherwise
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - true if value is a computed signal, false otherwise
  */
 const isComputed = /*#__PURE__*/ <T extends {}>(
 	value: unknown,
@@ -168,18 +179,18 @@ const isComputed = /*#__PURE__*/ <T extends {}>(
  * Check if the provided value is a callback that may be used as input for toSignal() to derive a computed state
  *
  * @since 0.12.0
- * @param {unknown} value - value to check
+ * @param {unknown} value - Value to check
  * @returns {boolean} - true if value is a callback or callbacks object, false otherwise
  */
 const isComputedCallback = /*#__PURE__*/ <T extends {}>(
 	value: unknown,
-): value is ComputedCallback<T> => isFunction(value) && value.length < 2
+): value is ComputedCallback<T> => isFunction(value) && value.length < 3
 
 /* === Exports === */
 
 export {
 	TYPE_COMPUTED,
-	computed,
+	createComputed,
 	isComputed,
 	isComputedCallback,
 	type Computed,

package/src/diff.ts

@@ -1,12 +1,14 @@
-import { UNSET } from './signal'
-import { CircularDependencyError, isRecord } from './util'
+import { CircularDependencyError } from './errors'
+import { isRecord, isRecordOrArray, UNSET } from './util'
 
 /* === Types === */
 
 type UnknownRecord = Record<string, unknown & {}>
-type UnknownRecordOrArray = {
-	[x: string | number]: unknown & {}
+type UnknownArray = ReadonlyArray<unknown & {}>
+type ArrayToRecord<T extends UnknownArray> = {
+	[key: string]: T extends Array<infer U extends {}> ? U : never
 }
+type UnknownRecordOrArray = UnknownRecord | ArrayToRecord<UnknownArray>
 
 type DiffResult<T extends UnknownRecordOrArray = UnknownRecord> = {
 	changed: boolean
@@ -69,6 +71,8 @@ const isEqual = <T>(a: T, b: T, visited?: WeakSet<object>): boolean => {
 			return true
 		}
 
+		// For non-records/non-arrays, they are only equal if they are the same reference
+		// (which would have been caught by Object.is at the beginning)
 		return false
 	} finally {
 		visited.delete(a as object)
@@ -88,61 +92,70 @@ const diff = <T extends UnknownRecordOrArray>(
 	oldObj: T,
 	newObj: T,
 ): DiffResult<T> => {
-	const visited = new WeakSet<object>()
-
-	const diffRecords = (
-		oldRecord: Record<string, unknown>,
-		newRecord: Record<string, unknown>,
-	): DiffResult<T> => {
-		const add: Partial<T> = {}
-		const change: Partial<T> = {}
-		const remove: Partial<T> = {}
-
-		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 as keyof T] = newRecord[key] as T[keyof T]
-				continue
-			} else if (oldHas && !newHas) {
-				remove[key as keyof T] = UNSET
-				continue
-			}
+	// Guard against non-objects that can't be diffed properly with Object.keys and 'in' operator
+	const oldValid = isRecordOrArray(oldObj)
+	const newValid = isRecordOrArray(newObj)
+	if (!oldValid || !newValid) {
+		// For non-objects or non-plain objects, treat as complete change if different
+		const changed = !Object.is(oldObj, newObj)
+		return {
+			changed,
+			add: changed && newValid ? newObj : {},
+			change: {},
+			remove: changed && oldValid ? oldObj : {},
+		}
+	}
 
-			const oldValue = oldRecord[key] as T[keyof T]
-			const newValue = newRecord[key] as T[keyof T]
+	const visited = new WeakSet()
 
-			if (!isEqual(oldValue, newValue, visited))
-				change[key as keyof T] = newValue
-		}
+	const add: Partial<T> = {}
+	const change: Partial<T> = {}
+	const remove: Partial<T> = {}
 
-		const changed =
-			Object.keys(add).length > 0 ||
-			Object.keys(change).length > 0 ||
-			Object.keys(remove).length > 0
+	const oldKeys = Object.keys(oldObj)
+	const newKeys = Object.keys(newObj)
+	const allKeys = new Set([...oldKeys, ...newKeys])
 
-		return {
-			changed,
-			add,
-			change,
-			remove,
+	for (const key of allKeys) {
+		const oldHas = key in oldObj
+		const newHas = key in newObj
+
+		if (!oldHas && newHas) {
+			add[key as keyof T] = newObj[key] as T[keyof T]
+			continue
+		} else if (oldHas && !newHas) {
+			remove[key as keyof T] = UNSET
+			continue
 		}
+
+		const oldValue = oldObj[key] as T[keyof T]
+		const newValue = newObj[key] as T[keyof T]
+
+		if (!isEqual(oldValue, newValue, visited))
+			change[key as keyof T] = newValue
 	}
 
-	return diffRecords(oldObj, newObj)
+	const changed =
+		Object.keys(add).length > 0 ||
+		Object.keys(change).length > 0 ||
+		Object.keys(remove).length > 0
+
+	return {
+		changed,
+		add,
+		change,
+		remove,
+	}
 }
 
 /* === Exports === */
 
 export {
+	type ArrayToRecord,
 	type DiffResult,
 	diff,
 	isEqual,
 	type UnknownRecord,
+	type UnknownArray,
 	type UnknownRecordOrArray,
 }

package/src/effect.ts

@@ -1,10 +1,6 @@
-import { type Cleanup, observe, watch } from './scheduler'
-import {
-	CircularDependencyError,
-	isAbortError,
-	isAsyncFunction,
-	isFunction,
-} from './util'
+import { CircularDependencyError, InvalidCallbackError } from './errors'
+import { type Cleanup, createWatcher, observe } from './system'
+import { isAbortError, isAsyncFunction, isFunction, valueString } from './util'
 
 /* === Types === */
 
@@ -28,12 +24,15 @@ type EffectCallback =
  * @param {EffectCallback} callback - Synchronous or asynchronous effect callback
  * @returns {Cleanup} - Cleanup function for the effect
  */
-const effect = (callback: EffectCallback): Cleanup => {
-	const isAsync = isAsyncFunction<MaybeCleanup>(callback)
+const createEffect = (callback: EffectCallback): Cleanup => {
+	if (!isFunction(callback) || callback.length > 1)
+		throw new InvalidCallbackError('effect', valueString(callback))
+
+	const isAsync = isAsyncFunction(callback)
 	let running = false
 	let controller: AbortController | undefined
 
-	const run = watch(() =>
+	const watcher = createWatcher(() =>
 		observe(() => {
 			if (running) throw new CircularDependencyError('effect')
 			running = true
@@ -56,7 +55,7 @@ const effect = (callback: EffectCallback): Cleanup => {
 								isFunction(cleanup) &&
 								controller === currentController
 							)
-								run.off(cleanup)
+								watcher.unwatch(cleanup)
 						})
 						.catch(error => {
 							if (!isAbortError(error))
@@ -64,7 +63,7 @@ const effect = (callback: EffectCallback): Cleanup => {
 						})
 				} else {
 					cleanup = (callback as () => MaybeCleanup)()
-					if (isFunction(cleanup)) run.off(cleanup)
+					if (isFunction(cleanup)) watcher.unwatch(cleanup)
 				}
 			} catch (error) {
 				if (!isAbortError(error))
@@ -72,16 +71,16 @@ const effect = (callback: EffectCallback): Cleanup => {
 			}
 
 			running = false
-		}, run),
+		}, watcher),
 	)
 
-	run()
+	watcher()
 	return () => {
 		controller?.abort()
-		run.cleanup()
+		watcher.cleanup()
 	}
 }
 
 /* === Exports === */
 
-export { type MaybeCleanup, type EffectCallback, effect }
+export { type MaybeCleanup, type EffectCallback, createEffect }

package/src/errors.ts

@@ -0,0 +1,64 @@
+class CircularDependencyError extends Error {
+	constructor(where: string) {
+		super(`Circular dependency detected in ${where}`)
+		this.name = 'CircularDependencyError'
+	}
+}
+
+class InvalidCallbackError extends TypeError {
+	constructor(where: string, value: string) {
+		super(`Invalid ${where} callback ${value}`)
+		this.name = 'InvalidCallbackError'
+	}
+}
+
+class InvalidSignalValueError extends TypeError {
+	constructor(where: string, value: string) {
+		super(`Invalid signal value ${value} in ${where}`)
+		this.name = 'InvalidSignalValueError'
+	}
+}
+
+class NullishSignalValueError extends TypeError {
+	constructor(where: string) {
+		super(`Nullish signal values are not allowed in ${where}`)
+		this.name = 'NullishSignalValueError'
+	}
+}
+
+class StoreKeyExistsError extends Error {
+	constructor(key: string, value: string) {
+		super(
+			`Could not add store key "${key}" with value ${value} because it already exists`,
+		)
+		this.name = 'StoreKeyExistsError'
+	}
+}
+
+class StoreKeyRangeError extends RangeError {
+	constructor(index: number) {
+		super(
+			`Could not remove store index ${String(index)} because it is out of range`,
+		)
+		this.name = 'StoreKeyRangeError'
+	}
+}
+
+class StoreKeyReadonlyError extends Error {
+	constructor(key: string, value: string) {
+		super(
+			`Could not set store key "${key}" to ${value} because it is readonly`,
+		)
+		this.name = 'StoreKeyReadonlyError'
+	}
+}
+
+export {
+	CircularDependencyError,
+	InvalidCallbackError,
+	InvalidSignalValueError,
+	NullishSignalValueError,
+	StoreKeyExistsError,
+	StoreKeyRangeError,
+	StoreKeyReadonlyError,
+}

package/src/match.ts

@@ -5,7 +5,7 @@ import { toError } from './util'
 /* === Types === */
 
 type MatchHandlers<S extends UnknownSignalRecord> = {
-	ok?: (values: SignalValues<S>) => void
+	ok: (values: SignalValues<S>) => void
 	err?: (errors: readonly Error[]) => void
 	nil?: () => void
 }
@@ -31,7 +31,7 @@ function match<S extends UnknownSignalRecord>(
 	try {
 		if (result.pending) handlers.nil?.()
 		else if (result.errors) handlers.err?.(result.errors)
-		else handlers.ok?.(result.values as SignalValues<S>)
+		else if (result.ok) handlers.ok(result.values)
 	} catch (error) {
 		// If handler throws, try error handler, otherwise rethrow
 		if (

package/src/resolve.ts

@@ -1,6 +1,6 @@
 import type { UnknownRecord } from './diff'
-import { type SignalValues, UNSET, type UnknownSignalRecord } from './signal'
-import { toError } from './util'
+import type { SignalValues, UnknownSignalRecord } from './signal'
+import { toError, UNSET } from './util'
 
 /* === Types === */