@zeix/cause-effect 0.16.1 → 0.17.1

package/index.js

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

package/index.ts

@@ -1,22 +1,49 @@
 /**
  * @name Cause & Effect
- * @version 0.16.1
+ * @version 0.17.1
  * @author Esther Brunner
  */
 
+export {
+	type Collection,
+	type CollectionCallback,
+	type CollectionSource,
+	DerivedCollection,
+	isCollection,
+	TYPE_COLLECTION,
+} from './src/classes/collection'
 export {
 	type Computed,
-	type ComputedCallback,
 	createComputed,
 	isComputed,
-	isComputedCallback,
+	isMemoCallback,
+	isTaskCallback,
+	Memo,
+	type MemoCallback,
+	Task,
+	type TaskCallback,
 	TYPE_COMPUTED,
-} from './src/computed'
+} from './src/classes/computed'
+export {
+	type ArrayToRecord,
+	isList,
+	type KeyConfig,
+	List,
+	TYPE_LIST,
+} from './src/classes/list'
+export { isRef, Ref, TYPE_REF } from './src/classes/ref'
+export { isState, State, TYPE_STATE } from './src/classes/state'
+export {
+	BaseStore,
+	createStore,
+	isStore,
+	type Store,
+	TYPE_STORE,
+} from './src/classes/store'
 export {
 	type DiffResult,
 	diff,
 	isEqual,
-	type PartialRecord,
 	type UnknownArray,
 	type UnknownRecord,
 } from './src/diff'
@@ -27,39 +54,40 @@ export {
 } from './src/effect'
 export {
 	CircularDependencyError,
+	createError,
+	DuplicateKeyError,
+	type Guard,
+	guardMutableSignal,
 	InvalidCallbackError,
+	InvalidCollectionSourceError,
 	InvalidSignalValueError,
 	NullishSignalValueError,
-	StoreKeyExistsError,
-	StoreKeyRangeError,
-	StoreKeyReadonlyError,
+	ReadonlySignalError,
+	validateCallback,
+	validateSignalValue,
 } from './src/errors'
 export { type MatchHandlers, match } from './src/match'
 export { type ResolveResult, resolve } from './src/resolve'
 export {
+	createSignal,
 	isMutableSignal,
 	isSignal,
 	type Signal,
 	type SignalValues,
-	toSignal,
 	type UnknownSignalRecord,
 } from './src/signal'
-export { createState, isState, type State, TYPE_STATE } from './src/state'
-export {
-	createStore,
-	isStore,
-	type Store,
-	type StoreChanges,
-	TYPE_STORE,
-} from './src/store'
 export {
-	batch,
+	batchSignalWrites,
 	type Cleanup,
 	createWatcher,
-	flush,
-	notify,
-	observe,
-	subscribe,
+	emitNotification,
+	flushPendingReactions,
+	type Listener,
+	type Listeners,
+	type Notifications,
+	notifyWatchers,
+	subscribeActiveWatcher,
+	trackSignalReads,
 	type Watcher,
 } from './src/system'
 export {
@@ -72,7 +100,6 @@ export {
 	isRecordOrArray,
 	isString,
 	isSymbol,
-	toError,
 	UNSET,
 	valueString,
 } from './src/util'

package/package.json

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

package/src/classes/collection.ts

@@ -0,0 +1,282 @@
+import { InvalidCollectionSourceError, validateCallback } from '../errors'
+import type { Signal } from '../signal'
+import {
+	type Cleanup,
+	createWatcher,
+	emitNotification,
+	type Listener,
+	type Listeners,
+	notifyWatchers,
+	subscribeActiveWatcher,
+	trackSignalReads,
+	type Watcher,
+} from '../system'
+import { isAsyncFunction, isFunction, isObjectOfType, UNSET } from '../util'
+import { type Computed, createComputed } from './computed'
+import { isList, type List } from './list'
+
+/* === Types === */
+
+type CollectionSource<T extends {}> = List<T> | Collection<T>
+
+type CollectionCallback<T extends {}, U extends {}> =
+	| ((sourceValue: U) => T)
+	| ((sourceValue: U, abort: AbortSignal) => Promise<T>)
+
+type Collection<T extends {}> = {
+	readonly [Symbol.toStringTag]: 'Collection'
+	readonly [Symbol.isConcatSpreadable]: true
+	[Symbol.iterator](): IterableIterator<Signal<T>>
+	get: () => T[]
+	at: (index: number) => Signal<T> | undefined
+	byKey: (key: string) => Signal<T> | undefined
+	keyAt: (index: number) => string | undefined
+	indexOfKey: (key: string) => number | undefined
+	on: <K extends keyof Listeners>(type: K, listener: Listener<K>) => Cleanup
+	deriveCollection: <R extends {}>(
+		callback: CollectionCallback<R, T>,
+	) => DerivedCollection<R, T>
+	readonly length: number
+}
+
+/* === Constants === */
+
+const TYPE_COLLECTION = 'Collection' as const
+
+/* === Class === */
+
+class DerivedCollection<T extends {}, U extends {}> implements Collection<T> {
+	#watchers = new Set<Watcher>()
+	#source: CollectionSource<U>
+	#callback: CollectionCallback<T, U>
+	#signals = new Map<string, Computed<T>>()
+	#ownWatchers = new Map<string, Watcher>()
+	#listeners: Listeners = {
+		add: new Set<Listener<'add'>>(),
+		change: new Set<Listener<'change'>>(),
+		remove: new Set<Listener<'remove'>>(),
+		sort: new Set<Listener<'sort'>>(),
+	}
+	#order: string[] = []
+
+	constructor(
+		source: CollectionSource<U> | (() => CollectionSource<U>),
+		callback: CollectionCallback<T, U>,
+	) {
+		validateCallback('collection', callback)
+
+		if (isFunction(source)) source = source()
+		if (!isCollectionSource(source))
+			throw new InvalidCollectionSourceError('derived collection', source)
+		this.#source = source
+
+		this.#callback = callback
+
+		for (let i = 0; i < this.#source.length; i++) {
+			const key = this.#source.keyAt(i)
+			if (!key) continue
+
+			this.#add(key)
+		}
+
+		this.#source.on('add', additions => {
+			for (const key of additions) {
+				if (!this.#signals.has(key)) {
+					this.#add(key)
+					// For async computations, trigger initial computation
+					const signal = this.#signals.get(key)
+					if (signal && isAsyncCollectionCallback(this.#callback))
+						signal.get()
+				}
+			}
+			notifyWatchers(this.#watchers)
+			emitNotification(this.#listeners.add, additions)
+		})
+
+		this.#source.on('remove', removals => {
+			for (const key of removals) {
+				if (!this.#signals.has(key)) continue
+
+				this.#signals.delete(key)
+				const index = this.#order.indexOf(key)
+				if (index >= 0) this.#order.splice(index, 1)
+
+				const watcher = this.#ownWatchers.get(key)
+				if (watcher) {
+					watcher.stop()
+					this.#ownWatchers.delete(key)
+				}
+			}
+			this.#order = this.#order.filter(() => true) // Compact array
+			notifyWatchers(this.#watchers)
+			emitNotification(this.#listeners.remove, removals)
+		})
+
+		this.#source.on('sort', newOrder => {
+			this.#order = [...newOrder]
+			notifyWatchers(this.#watchers)
+			emitNotification(this.#listeners.sort, newOrder)
+		})
+	}
+
+	#add(key: string): boolean {
+		const computedCallback = isAsyncCollectionCallback<T>(this.#callback)
+			? async (_: T, abort: AbortSignal) => {
+					const sourceSignal = this.#source.byKey(key)
+					if (!sourceSignal) return UNSET
+
+					const sourceValue = sourceSignal.get() as U
+					if (sourceValue === UNSET) return UNSET
+					return this.#callback(sourceValue, abort)
+				}
+			: () => {
+					const sourceSignal = this.#source.byKey(key)
+					if (!sourceSignal) return UNSET
+
+					const sourceValue = sourceSignal.get() as U
+					if (sourceValue === UNSET) return UNSET
+					return (this.#callback as (sourceValue: U) => T)(
+						sourceValue,
+					)
+				}
+
+		const signal = createComputed(computedCallback)
+
+		this.#signals.set(key, signal)
+		if (!this.#order.includes(key)) this.#order.push(key)
+		if (this.#listeners.change.size) this.#addWatcher(key)
+		return true
+	}
+
+	#addWatcher(key: string): void {
+		const watcher = createWatcher(() => {
+			trackSignalReads(watcher, () => {
+				this.#signals.get(key)?.get() // Subscribe to the signal
+			})
+		})
+		this.#ownWatchers.set(key, watcher)
+		watcher()
+	}
+
+	get [Symbol.toStringTag](): 'Collection' {
+		return TYPE_COLLECTION
+	}
+
+	get [Symbol.isConcatSpreadable](): true {
+		return true
+	}
+
+	*[Symbol.iterator](): IterableIterator<Computed<T>> {
+		for (const key of this.#order) {
+			const signal = this.#signals.get(key)
+			if (signal) yield signal as Computed<T>
+		}
+	}
+
+	get length(): number {
+		subscribeActiveWatcher(this.#watchers)
+		return this.#order.length
+	}
+
+	get(): T[] {
+		subscribeActiveWatcher(this.#watchers)
+		return this.#order
+			.map(key => this.#signals.get(key)?.get())
+			.filter(v => v != null && v !== UNSET) as T[]
+	}
+
+	at(index: number): Computed<T> | undefined {
+		return this.#signals.get(this.#order[index])
+	}
+
+	keys(): IterableIterator<string> {
+		return this.#order.values()
+	}
+
+	byKey(key: string): Computed<T> | undefined {
+		return this.#signals.get(key)
+	}
+
+	keyAt(index: number): string | undefined {
+		return this.#order[index]
+	}
+
+	indexOfKey(key: string): number {
+		return this.#order.indexOf(key)
+	}
+
+	on<K extends keyof Listeners>(type: K, listener: Listener<K>): Cleanup {
+		this.#listeners[type].add(listener)
+		if (type === 'change' && !this.#ownWatchers.size) {
+			for (const key of this.#signals.keys()) this.#addWatcher(key)
+		}
+
+		return () => {
+			this.#listeners[type].delete(listener)
+			if (type === 'change' && !this.#listeners.change.size) {
+				if (this.#ownWatchers.size) {
+					for (const watcher of this.#ownWatchers.values())
+						watcher.stop()
+					this.#ownWatchers.clear()
+				}
+			}
+		}
+	}
+
+	deriveCollection<R extends {}>(
+		callback: (sourceValue: T) => R,
+	): DerivedCollection<R, T>
+	deriveCollection<R extends {}>(
+		callback: (sourceValue: T, abort: AbortSignal) => Promise<R>,
+	): DerivedCollection<R, T>
+	deriveCollection<R extends {}>(
+		callback: CollectionCallback<R, T>,
+	): DerivedCollection<R, T> {
+		return new DerivedCollection(this, callback)
+	}
+}
+
+/* === Functions === */
+
+/**
+ * Check if a value is a collection signal
+ *
+ * @since 0.17.0
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - True if value is a collection signal, false otherwise
+ */
+const isCollection = /*#__PURE__*/ <T extends {}, U extends {}>(
+	value: unknown,
+): value is DerivedCollection<T, U> => isObjectOfType(value, TYPE_COLLECTION)
+
+/**
+ * Check if a value is a collection source
+ *
+ * @since 0.17.0
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - True if value is a collection source, false otherwise
+ */
+const isCollectionSource = /*#__PURE__*/ <T extends {}>(
+	value: unknown,
+): value is CollectionSource<T> => isList(value) || isCollection(value)
+
+/**
+ * Check if the provided callback is an async function
+ *
+ * @since 0.17.0
+ * @param {unknown} callback - Value to check
+ * @returns {boolean} - True if value is an async collection callback, false otherwise
+ */
+const isAsyncCollectionCallback = <T extends {}>(
+	callback: unknown,
+): callback is (sourceValue: unknown, abort: AbortSignal) => Promise<T> =>
+	isAsyncFunction(callback)
+
+export {
+	type Collection,
+	type CollectionSource,
+	type CollectionCallback,
+	DerivedCollection,
+	isCollection,
+	TYPE_COLLECTION,
+}

package/src/classes/composite.ts

@@ -0,0 +1,176 @@
+import type { DiffResult, UnknownRecord } from '../diff'
+import { guardMutableSignal } from '../errors'
+import type { Signal } from '../signal'
+import {
+	batchSignalWrites,
+	type Cleanup,
+	createWatcher,
+	emitNotification,
+	type Listener,
+	type Listeners,
+	trackSignalReads,
+	type Watcher,
+} from '../system'
+
+/* === Types === */
+
+type CompositeListeners = Pick<Listeners, 'add' | 'change' | 'remove'>
+
+/* === Class Definitions === */
+
+class Composite<T extends UnknownRecord, S extends Signal<T[keyof T] & {}>> {
+	signals = new Map<string, S>()
+	#validate: <K extends keyof T & string>(
+		key: K,
+		value: unknown,
+	) => value is T[K] & {}
+	#create: <V extends T[keyof T] & {}>(value: V) => S
+	#watchers = new Map<string, Watcher>()
+	#listeners: CompositeListeners = {
+		add: new Set<Listener<'add'>>(),
+		change: new Set<Listener<'change'>>(),
+		remove: new Set<Listener<'remove'>>(),
+	}
+	#batching = false
+
+	constructor(
+		values: T,
+		validate: <K extends keyof T & string>(
+			key: K,
+			value: unknown,
+		) => value is T[K] & {},
+		create: <V extends T[keyof T] & {}>(value: V) => S,
+	) {
+		this.#validate = validate
+		this.#create = create
+		this.change(
+			{
+				add: values,
+				change: {},
+				remove: {},
+				changed: true,
+			},
+			true,
+		)
+	}
+
+	#addWatcher(key: string): void {
+		const watcher = createWatcher(() => {
+			trackSignalReads(watcher, () => {
+				this.signals.get(key)?.get() // Subscribe to the signal
+				if (!this.#batching)
+					emitNotification(this.#listeners.change, [key])
+			})
+		})
+		this.#watchers.set(key, watcher)
+		watcher()
+	}
+
+	add<K extends keyof T & string>(key: K, value: T[K]): boolean {
+		if (!this.#validate(key, value)) return false
+
+		this.signals.set(key, this.#create(value))
+		if (this.#listeners.change.size) this.#addWatcher(key)
+
+		if (!this.#batching) emitNotification(this.#listeners.add, [key])
+		return true
+	}
+
+	remove<K extends keyof T & string>(key: K): boolean {
+		const ok = this.signals.delete(key)
+		if (!ok) return false
+
+		const watcher = this.#watchers.get(key)
+		if (watcher) {
+			watcher.stop()
+			this.#watchers.delete(key)
+		}
+
+		if (!this.#batching) emitNotification(this.#listeners.remove, [key])
+		return true
+	}
+
+	change(changes: DiffResult, initialRun?: boolean): boolean {
+		this.#batching = true
+
+		// Additions
+		if (Object.keys(changes.add).length) {
+			for (const key in changes.add)
+				this.add(
+					key as Extract<keyof T, string>,
+					changes.add[key] as T[Extract<keyof T, string>] & {},
+				)
+
+			// Queue initial additions event to allow listeners to be added first
+			const notify = () =>
+				emitNotification(this.#listeners.add, Object.keys(changes.add))
+			if (initialRun) setTimeout(notify, 0)
+			else notify()
+		}
+
+		// Changes
+		if (Object.keys(changes.change).length) {
+			batchSignalWrites(() => {
+				for (const key in changes.change) {
+					const value = changes.change[key]
+					if (!this.#validate(key as keyof T & string, value))
+						continue
+
+					const signal = this.signals.get(key)
+					if (guardMutableSignal(`list item "${key}"`, value, signal))
+						signal.set(value)
+				}
+			})
+			emitNotification(
+				this.#listeners.change,
+				Object.keys(changes.change),
+			)
+		}
+
+		// Removals
+		if (Object.keys(changes.remove).length) {
+			for (const key in changes.remove)
+				this.remove(key as keyof T & string)
+			emitNotification(
+				this.#listeners.remove,
+				Object.keys(changes.remove),
+			)
+		}
+
+		this.#batching = false
+		return changes.changed
+	}
+
+	clear(): boolean {
+		const keys = Array.from(this.signals.keys())
+		this.signals.clear()
+		this.#watchers.clear()
+		emitNotification(this.#listeners.remove, keys)
+		return true
+	}
+
+	on<K extends keyof CompositeListeners>(
+		type: K,
+		listener: Listener<K>,
+	): Cleanup {
+		this.#listeners[type].add(listener)
+		if (type === 'change' && !this.#watchers.size) {
+			this.#batching = true
+			for (const key of this.signals.keys()) this.#addWatcher(key)
+			this.#batching = false
+		}
+
+		return () => {
+			this.#listeners[type].delete(listener)
+			if (type === 'change' && !this.#listeners.change.size) {
+				if (this.#watchers.size) {
+					for (const watcher of this.#watchers.values())
+						watcher.stop()
+					this.#watchers.clear()
+				}
+			}
+		}
+	}
+}
+
+export { Composite, type CompositeListeners }