@zeix/cause-effect 0.14.0 → 0.14.2

package/README.md

@@ -1,6 +1,6 @@
 # Cause & Effect
 
-Version 0.14.0
+Version 0.14.2
 
 **Cause & Effect** is a lightweight, reactive state management library for JavaScript applications. It uses fine-grained reactivity with signals to create predictable and efficient data flow in your app.
 
@@ -10,9 +10,9 @@ Version 0.14.0
 
 ### Core Concepts
 
-- **State signals**: Hold values that can be directly modified
-- **Computed signals**: Derive values from other signals (either `memo()` for sync or `task()` for async)
-- **Effects**: Run side effects when signals change
+- **State signals**: Hold values that can be directly modified: `state()`
+- **Computed signals**: Derive memoized values from other signals: `computed()`
+- **Effects**: Run side effects when signals change: `effect()`
 
 ## Key Features
 
@@ -26,20 +26,17 @@ Version 0.14.0
 ## Quick Start
 
 ```js
-import { state, memo, effect } from '@zeix/cause-effect'
+import { state, computed, effect } from '@zeix/cause-effect'
 
 // 1. Create state
 const user = state({ name: 'Alice', age: 30 })
 
 // 2. Create computed values
-const greeting = memo(() => `Hello ${user.get().name}!`)
+const greeting = computed(() => `Hello ${user.get().name}!`)
 
 // 3. React to changes
-effect({
-  signals: [user, greeting],
-  ok: ({ age }, greet) => {
-    console.log(`${greet} You are ${age} years old`)
-  }
+effect(() => {
+  console.log(`${greeting.get()} You are ${user.get().age} years old`)
 })
 
 // 4. Update state
@@ -76,61 +73,85 @@ document.querySelector('.increment').addEventListener('click', () => {
 // Click on button logs '25', '26', and so on
 ```
 
-### Computed Signals: memo() and task()
+### Computed Signals vs. Functions
 
-#### Synchronous Computations with memo()
+#### When to Use Computed Signals
 
-`memo()` creates a read-only computed signal for synchronous calculations. It automatically tracks dependencies and updates when they change.
+`computed()` creates a memoized read-only signal that automatically tracks dependencies and updates only when those dependencies change.
 
 ```js
-import { state, memo, effect } from '@zeix/cause-effect'
+import { state, computed, effect } from '@zeix/cause-effect'
 
 const count = state(42)
-const isOdd = memo(() => count.get() % 2)
-effect(() => console.log(isOdd.get())) // logs 'false'
+const isEven = computed(() => !(count.get() % 2))
+effect(() => console.log(isEven.get())) // logs 'true'
 count.set(24) // logs nothing because 24 is also an even number
 document.querySelector('button.increment').addEventListener('click', () => {
   count.update(v => ++v)
 })
-// Click on button logs 'true', 'false', and so on
+// Click on button logs 'false', 'true', and so on
+```
+
+#### When to Use Functions
+
+**Performance tip**: For simple derivations, plain functions often outperform computed signals:
+
+```js
+// More performant for simple calculations
+const isEven = () => !(count.get() % 2)
 ```
 
-#### Asynchronous Computations with task()
+**When to use which approach:**
 
-`task()` creates computed signals for asynchronous operations. It automatically manages promises, tracks dependencies, and handles cancellation through `AbortController`.
+- **Use functions when**: The calculation is simple, inexpensive, or called infrequently
+- **Use computed() when**:
+  - The calculation is expensive
+  - You need to share the result between multiple consumers
+  - You're working with asynchronous operations
+  - You need to track specific error states
 
-**Note**: Task signals return `UNSET` while pending, which you can handle with the `nil` case in effects.
+#### Asynchronous Computations with Automatic Cancellation
+
+`computed()` seamlessly handles asynchronous operations with built-in cancellation support. When used with an async function, it:
+
+1. Provides an `abort` signal parameter you can pass to fetch or other cancelable APIs
+2. Automatically cancels pending operations when dependencies change
+3. Returns `UNSET` while the Promise is pending
+4. Properly handles errors from failed requests
 
 ```js
-import { state, task, effect } from '@zeix/cause-effect'
+import { state, computed, effect } from '@zeix/cause-effect'
 
-const entryId = state(42)
-const entryData = task(async abort => {
-  const response = await fetch(`/api/entry/${entryId.get()}`, { signal: abort })
+const id = state(42)
+const data = computed(async abort => {
+  // The abort signal is automatically managed by the computed signal
+  const response = await fetch(`/api/entries/${id.get()}`, { signal: abort })
   if (!response.ok) throw new Error(`Failed to fetch data: ${response.statusText}`)
   return response.json()
 })
 
-// Display data when available
+// Handle all possible states
 effect({
-  signals: [entryData],
-  ok: data => console.log('Data loaded:', data),
+  signals: [data],
+  ok: json => console.log('Data loaded:', json),
   nil: () => console.log('Loading...'),
   err: error => console.error('Error:', error)
 })
 
-// Move to next entry, automatically triggers a new fetch
+// When id changes, the previous request is automatically canceled
 document.querySelector('button.next').addEventListener('click', () => {
-  entryId.update(v => ++v)
+  id.update(v => ++v)
 })
 ```
 
+**Note**: Always use `computed()` (not plain functions) for async operations to benefit from automatic cancellation, memoization, and state management.
+
 ## Effects and Error Handling
 
 Cause & Effect provides a robust way to handle side effects and errors through the `effect()` function, with three distinct paths:
 
 1. **Ok**: When values are available
-2. **Nil**: For loading/unset states (primarily with async tasks)
+2. **Nil**: For loading/unset states (with async tasks)
 3. **Err**: When errors occur during computation
 
 This allows for declarative handling of all possible states:
@@ -138,13 +159,13 @@ This allows for declarative handling of all possible states:
 ```js
 effect({
   signals: [data],
-  ok: (value) => /* update UI */,
-  nil: () => /* show loading */,
-  err: (error) => /* show error */
+  ok: (value) => /* update UI when data is available */,
+  nil: () => /* show loading state while pending */,
+  err: (error) => /* show error message when computation fails */
 })
 ```
 
-Instead of using a single callback function, you can provide an object with an `ok` handler (required), plus optional `err` and `nil` handlers. Cause & Effect will automatically route to the appropriate handler based on the state of the signals.
+Instead of using a single callback function, you can provide an object with an `ok` handler (required), plus optional `err` and `nil` handlers. Cause & Effect will automatically route to the appropriate handler based on the state of the signals. If not provided, Cause & Effect will assume `console.error` for `err` and a no-op for `nil`.
 
 ## DOM Updates
 
@@ -237,13 +258,13 @@ Using Symbols for deduplication provides:
 Use `batch()` to group multiple signal updates, ensuring effects run only once after all changes are applied:
 
 ```js
-import { state, memo, effect, batch } from '@zeix/cause-effect'
+import { state, computed, effect, batch } from '@zeix/cause-effect'
 
 // State: define an array of State<number>
 const signals = [state(2), state(3), state(5)]
 
 // Compute the sum of all signals
-const sum = memo(() => {
+const sum = computed(() => {
   const v = signals.reduce((total, signal) => total + signal.get(), 0)
   // Validate the result
   if (!Number.isFinite(v)) throw new Error('Invalid value')
@@ -260,7 +281,9 @@ effect({
 // Batch: apply changes to all signals in a single transaction
 document.querySelector('.double-all').addEventListener('click', () => {
   batch(() => {
-    signals.forEach(signal => signal.update(v => v * 2))
+    signals.forEach(signal => {
+      signal.update(v => v * 2)
+    })
   })
 })
 // Click on button logs '20' only once
@@ -274,6 +297,7 @@ The Cause & Effect library is designed around these principles:
 
 - **Minimal API**: Core primitives with a small but powerful interface
 - **Automatic Dependency Tracking**: Fine-grained reactivity with minimal boilerplate
+- **Performance-Focused**: Choose the right tool (functions vs computed) for optimal speed
 - **Tree-Shakable**: Import only what you need for optimal bundle size
 - **Flexible Integration**: Works with any JavaScript application or framework
 
@@ -282,49 +306,21 @@ The Cause & Effect library is designed around these principles:
 Effects return a cleanup function. When executed, it will unsubscribe from signals and run cleanup functions returned by effect callbacks, for example to remove event listeners.
 
 ```js
-import { state, memo, effect } from '@zeix/cause-effect'
+import { state, computed, effect } from '@zeix/cause-effect'
 
 const user = state({ name: 'Alice', age: 30 })
-const greeting = memo(() => `Hello ${user.get().name}!`)
-const cleanup = effect({
-  signals: [user, greeting],
-  ok: ({ age }, greet) => {
-    console.log(`${greet} You are ${age} years old`)
-    return () => console.log('Cleanup') // Cleanup function
-  }
+const greeting = () => `Hello ${user.get().name}!`
+const cleanup = effect(() => {
+	console.log(`${greeting()} You are ${user.get().age} years old`)
+	return () => console.log('Cleanup') // Cleanup function
 })
 
 // When you no longer need the effect, execute the cleanup function
-cleanup() // Logs: 'Cleanup' and unsubscribes from signals `user` and `greeting`
+cleanup() // Logs: 'Cleanup' and unsubscribes from signal `user`
 
 user.set({ name: 'Bob', age: 28 }) // Won't trigger the effect anymore
 ```
 
-### Automatic Abort Control
-
-For asynchronous operations, `task()` automatically manages cancellation when dependencies change, providing an `abort` signal parameter:
-
-```js
-import { state, task, effect } from '@zeix/cause-effect'
-
-const id = state(42)
-const url = memo(v => `https://example.com/api/entries/${id.get()}`)
-const data = task(async abort => {
-  const response = await fetch(url.get(), { signal: abort })
-  if (!response.ok) throw new Error(`Failed to fetch data: ${response.statusText}`)
-  return response.json()
-})
-effect({
-  signals: [data],
-  ok: v => console.log('Value:', v),
-  nil: () => console.warn('Not ready'),
-  err: e => console.error('Error:', e)
-})
-
-// User switches to another entry
-id.set(24) // Cancels the previous fetch request and starts a new one
-```
-
 ## Contributing & License
 
 Feel free to contribute, report issues, or suggest improvements.

package/biome.json

@@ -0,0 +1,35 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.1.4/schema.json",
+	"vcs": {
+		"enabled": false,
+		"clientKind": "git",
+		"useIgnoreFile": false
+	},
+	"files": {
+		"ignoreUnknown": false,
+		"includes": ["**", "!index.js", "!index.dev.js", "!**/*.d.ts"]
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

package/index.d.ts

@@ -1,13 +1,11 @@
 /**
  * @name Cause & Effect
- * @version 0.14.0
+ * @version 0.14.2
  * @author Esther Brunner
  */
-export { CircularDependencyError } from './src/util';
-export { type Signal, type MaybeSignal, UNSET, isSignal, isComputedCallback, toSignal, } from './src/signal';
-export { type State, state, isState } from './src/state';
-export { type Computed, type ComputedCallback, computed, isComputed, } from './src/computed';
-export { type MemoCallback, memo } from './src/memo';
-export { type TaskCallback, task } from './src/task';
+export { type Computed, type ComputedCallback, computed, isComputed, TYPE_COMPUTED, } from './src/computed';
 export { type EffectMatcher, effect } from './src/effect';
-export { batch, watch, enqueue } from './src/scheduler';
+export { batch, type Cleanup, enqueue, flush, notify, observe, subscribe, type Updater, type Watcher, watch, } from './src/scheduler';
+export { isComputedCallback, isSignal, type MaybeSignal, type Signal, type SignalValues, toSignal, UNSET, } from './src/signal';
+export { isState, type State, state, TYPE_STATE } from './src/state';
+export { CircularDependencyError, isFunction } from './src/util';

package/index.dev.js

@@ -0,0 +1,294 @@
+// src/scheduler.ts
+var active;
+var pending = new Set;
+var batchDepth = 0;
+var updateMap = new Map;
+var requestId;
+var updateDOM = () => {
+  requestId = undefined;
+  const updates = Array.from(updateMap.values());
+  updateMap.clear();
+  for (const update of updates) {
+    update();
+  }
+};
+var requestTick = () => {
+  if (requestId)
+    cancelAnimationFrame(requestId);
+  requestId = requestAnimationFrame(updateDOM);
+};
+queueMicrotask(updateDOM);
+var watch = (notice) => {
+  const cleanups = new Set;
+  const w = notice;
+  w.off = (on) => {
+    cleanups.add(on);
+  };
+  w.cleanup = () => {
+    for (const cleanup of cleanups) {
+      cleanup();
+    }
+    cleanups.clear();
+  };
+  return w;
+};
+var subscribe = (watchers) => {
+  if (active && !watchers.has(active)) {
+    const watcher = active;
+    watchers.add(watcher);
+    active.off(() => {
+      watchers.delete(watcher);
+    });
+  }
+};
+var notify = (watchers) => {
+  for (const watcher of watchers) {
+    if (batchDepth)
+      pending.add(watcher);
+    else
+      watcher();
+  }
+};
+var flush = () => {
+  while (pending.size) {
+    const watchers = Array.from(pending);
+    pending.clear();
+    for (const watcher of watchers) {
+      watcher();
+    }
+  }
+};
+var batch = (fn) => {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    flush();
+    batchDepth--;
+  }
+};
+var observe = (run, watcher) => {
+  const prev = active;
+  active = watcher;
+  try {
+    run();
+  } finally {
+    active = prev;
+  }
+};
+var enqueue = (fn, dedupe) => new Promise((resolve, reject) => {
+  updateMap.set(dedupe || Symbol(), () => {
+    try {
+      resolve(fn());
+    } catch (error) {
+      reject(error);
+    }
+  });
+  requestTick();
+});
+
+// src/util.ts
+var isFunction = (value) => typeof value === "function";
+var isObjectOfType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
+var toError = (reason) => reason instanceof Error ? reason : Error(String(reason));
+
+class CircularDependencyError extends Error {
+  constructor(where) {
+    super(`Circular dependency in ${where} detected`);
+    this.name = "CircularDependencyError";
+  }
+}
+
+// src/state.ts
+var TYPE_STATE = "State";
+var state = (initialValue) => {
+  const watchers = new Set;
+  let value = initialValue;
+  const s = {
+    [Symbol.toStringTag]: TYPE_STATE,
+    get: () => {
+      subscribe(watchers);
+      return value;
+    },
+    set: (v) => {
+      if (Object.is(value, v))
+        return;
+      value = v;
+      notify(watchers);
+      if (UNSET === value)
+        watchers.clear();
+    },
+    update: (fn) => {
+      s.set(fn(value));
+    }
+  };
+  return s;
+};
+var isState = (value) => isObjectOfType(value, TYPE_STATE);
+
+// 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);
+
+// src/computed.ts
+var TYPE_COMPUTED = "Computed";
+var computed = (fn) => {
+  const watchers = new Set;
+  let value = UNSET;
+  let error;
+  let controller;
+  let dirty = true;
+  let changed = false;
+  let computing = false;
+  const ok = (v) => {
+    if (!Object.is(v, value)) {
+      value = v;
+      changed = true;
+    }
+    error = undefined;
+    dirty = false;
+  };
+  const nil = () => {
+    changed = UNSET !== value;
+    value = UNSET;
+    error = undefined;
+  };
+  const err = (e) => {
+    const newError = toError(e);
+    changed = !error || newError.name !== error.name || newError.message !== error.message;
+    value = UNSET;
+    error = newError;
+  };
+  const settle = (settleFn) => (arg) => {
+    computing = false;
+    controller = undefined;
+    settleFn(arg);
+    if (changed)
+      notify(watchers);
+  };
+  const mark = watch(() => {
+    dirty = true;
+    controller?.abort("Aborted because source signal changed");
+    if (watchers.size)
+      notify(watchers);
+    else
+      mark.cleanup();
+  });
+  const compute = () => observe(() => {
+    if (computing)
+      throw new CircularDependencyError("computed");
+    changed = false;
+    if (isFunction(fn) && fn.constructor.name === "AsyncFunction") {
+      if (controller)
+        return value;
+      controller = new AbortController;
+      controller.signal.addEventListener("abort", () => {
+        computing = false;
+        controller = undefined;
+        compute();
+      }, {
+        once: true
+      });
+    }
+    let result;
+    computing = true;
+    try {
+      result = controller ? fn(controller.signal) : fn();
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError")
+        nil();
+      else
+        err(e);
+      computing = false;
+      return;
+    }
+    if (result instanceof Promise)
+      result.then(settle(ok), settle(err));
+    else if (result == null || UNSET === result)
+      nil();
+    else
+      ok(result);
+    computing = false;
+  }, mark);
+  const c = {
+    [Symbol.toStringTag]: TYPE_COMPUTED,
+    get: () => {
+      subscribe(watchers);
+      flush();
+      if (dirty)
+        compute();
+      if (error)
+        throw error;
+      return value;
+    }
+  };
+  return c;
+};
+var isComputed = (value) => isObjectOfType(value, TYPE_COMPUTED);
+var isComputedCallback = (value) => isFunction(value) && value.length < 2;
+// src/effect.ts
+function effect(matcher) {
+  const {
+    signals,
+    ok,
+    err = (error) => {
+      console.error(error);
+    },
+    nil = () => {
+    }
+  } = isFunction(matcher) ? { signals: [], ok: matcher } : matcher;
+  let running = false;
+  const run = watch(() => observe(() => {
+    if (running)
+      throw new CircularDependencyError("effect");
+    running = true;
+    const errors = [];
+    let pending2 = false;
+    const values = signals.map((signal) => {
+      try {
+        const value = signal.get();
+        if (value === UNSET)
+          pending2 = true;
+        return value;
+      } catch (e) {
+        errors.push(toError(e));
+        return UNSET;
+      }
+    });
+    let cleanup;
+    try {
+      cleanup = pending2 ? nil() : errors.length ? err(...errors) : ok(...values);
+    } catch (e) {
+      cleanup = err(toError(e));
+    } finally {
+      if (isFunction(cleanup))
+        run.off(cleanup);
+    }
+    running = false;
+  }, run));
+  run();
+  return () => run.cleanup();
+}
+export {
+  watch,
+  toSignal,
+  subscribe,
+  state,
+  observe,
+  notify,
+  isState,
+  isSignal,
+  isFunction,
+  isComputedCallback,
+  isComputed,
+  flush,
+  enqueue,
+  effect,
+  computed,
+  batch,
+  UNSET,
+  TYPE_STATE,
+  TYPE_COMPUTED,
+  CircularDependencyError
+};

package/index.js

@@ -1 +1 @@
-var O=($)=>typeof $==="function",p=($)=>O($)&&$.constructor.name==="AsyncFunction",N=($,B)=>Object.prototype.toString.call($)===`[object ${B}]`,c=($)=>$ instanceof Error,q=($)=>$ instanceof DOMException&&$.name==="AbortError",d=($)=>$ instanceof Promise,M=($)=>c($)?$:Error(String($));class x extends Error{constructor($){super(`Circular dependency in ${$} detected`);return this}}var V,k=new Set,U=0,b=new Map,_,h=()=>{_=void 0;let $=Array.from(b.values());b.clear();for(let B of $)B()},n=()=>{if(_)cancelAnimationFrame(_);_=requestAnimationFrame(h)};queueMicrotask(h);var Y=($)=>{if(V&&!$.has(V)){let B=V;$.add(B),V.cleanups.add(()=>{$.delete(B)})}},A=($)=>{for(let B of $)if(U)k.add(B);else B()},C=()=>{while(k.size){let $=Array.from(k);k.clear();for(let B of $)B()}},l=($)=>{U++;try{$()}finally{C(),U--}},R=($,B)=>{let z=V;V=B;try{$()}finally{V=z}},u=($,B)=>new Promise((z,F)=>{b.set(B||Symbol(),()=>{try{z($())}catch(L){F(L)}}),n()});var v="State",S=($)=>{let B=new Set,z=$,F={[Symbol.toStringTag]:v,get:()=>{return Y(B),z},set:(L)=>{if(Object.is(z,L))return;if(z=L,A(B),K===z)B.clear()},update:(L)=>{F.set(L(z))}};return F},T=($)=>N($,v);var w=($)=>{let B=new Set,z=K,F,L=!0,X=!1,H=()=>{if(L=!0,B.size)A(B);else H.cleanups.forEach((W)=>W()),H.cleanups.clear()};H.cleanups=new Set;let Q=()=>R(()=>{if(X)throw new x("memo");X=!0;try{let W=$();if(W==null||K===W)z=K,F=void 0;else z=W,L=!1,F=void 0}catch(W){z=K,F=W instanceof Error?W:new Error(String(W))}finally{X=!1}},H);return{[Symbol.toStringTag]:y,get:()=>{if(Y(B),C(),L)Q();if(F)throw F;return z}}};var g=($)=>{let B=new Set,z=K,F,L=!0,X=!1,H=!1,Q,j=(J)=>{if(!Object.is(J,z))z=J,L=!1,F=void 0,X=!0},W=()=>{X=K!==z,z=K,F=void 0},D=(J)=>{let I=M(J);X=!(F&&I.name===F.name&&I.message===F.message),z=K,F=I},G=(J)=>{if(H=!1,Q=void 0,j(J),X)A(B)},Z=(J)=>{if(H=!1,Q=void 0,D(J),X)A(B)},i=()=>{H=!1,Q=void 0,m()},P=()=>{if(L=!0,Q?.abort("Aborted because source signal changed"),B.size)A(B);else P.cleanups.forEach((J)=>J()),P.cleanups.clear()};P.cleanups=new Set;let m=()=>R(()=>{if(H)throw new x("task");X=!1,Q=new AbortController,Q.signal.addEventListener("abort",i,{once:!0});let J;H=!0;try{J=$(Q.signal)}catch(I){if(q(I))W();else D(I);H=!1;return}if(d(J))J.then(G,Z);else if(J==null||K===J)W();else j(J);H=!1},P);return{[Symbol.toStringTag]:y,get:()=>{if(Y(B),C(),L)m();if(F)throw F;return z}}};var y="Computed",E=($)=>p($)?g($):w($),f=($)=>N($,y);var K=Symbol(),o=($)=>T($)||f($),s=($)=>O($)&&$.length<2,t=($)=>o($)?$:s($)?E($):S($);function r($){let{signals:B,ok:z,err:F=console.error,nil:L=()=>{}}=O($)?{signals:[],ok:$}:$,X=!1,H=()=>R(()=>{if(X)throw new x("effect");X=!0;let Q=void 0;try{let j=[],W=!1,D=B.map((G)=>{try{let Z=G.get();if(Z===K)W=!0;return Z}catch(Z){if(q(Z))throw Z;return j.push(M(Z)),K}});try{Q=W?L():j.length?F(...j):z(...D)}catch(G){if(q(G))throw G;let Z=M(G);Q=F(Z)}}catch(j){F(M(j))}if(O(Q))H.cleanups.add(Q);X=!1},H);return H.cleanups=new Set,H(),()=>{H.cleanups.forEach((Q)=>Q()),H.cleanups.clear()}}export{R as watch,t as toSignal,g as task,S as state,w as memo,T as isState,o as isSignal,s as isComputedCallback,f as isComputed,u as enqueue,r as effect,E as computed,l as batch,K as UNSET,x as CircularDependencyError};
+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};

package/index.ts

@@ -1,25 +1,37 @@
 /**
  * @name Cause & Effect
- * @version 0.14.0
+ * @version 0.14.2
  * @author Esther Brunner
  */
-export { CircularDependencyError } from './src/util'
-export {
-	type Signal,
-	type MaybeSignal,
-	UNSET,
-	isSignal,
-	isComputedCallback,
-	toSignal,
-} from './src/signal'
-export { type State, state, isState } from './src/state'
+
 export {
 	type Computed,
 	type ComputedCallback,
 	computed,
 	isComputed,
+	TYPE_COMPUTED,
 } from './src/computed'
-export { type MemoCallback, memo } from './src/memo'
-export { type TaskCallback, task } from './src/task'
 export { type EffectMatcher, effect } from './src/effect'
-export { batch, watch, enqueue } from './src/scheduler'
+export {
+	batch,
+	type Cleanup,
+	enqueue,
+	flush,
+	notify,
+	observe,
+	subscribe,
+	type Updater,
+	type Watcher,
+	watch,
+} from './src/scheduler'
+export {
+	isComputedCallback,
+	isSignal,
+	type MaybeSignal,
+	type Signal,
+	type SignalValues,
+	toSignal,
+	UNSET,
+} from './src/signal'
+export { isState, type State, state, TYPE_STATE } from './src/state'
+export { CircularDependencyError, isFunction } from './src/util'