@zeix/cause-effect 0.17.1 → 0.17.3

package/tsconfig.json

@@ -13,6 +13,9 @@
 		"allowImportingTsExtensions": true,
 		"verbatimModuleSyntax": true,
 
+		// Editor-only mode - no emit
+		"noEmit": true,
+
 		// Best practices
 		"strict": true,
 		"skipLibCheck": true,
@@ -22,12 +25,7 @@
 		"noUnusedLocals": false,
 		"noUnusedParameters": false,
 		"noPropertyAccessFromIndexSignature": false,
-
-		// Declarations
-		"declaration": true,
-		"declarationDir": "./types",
-		"emitDeclarationOnly": true
 	},
-	"include": ["./*.ts", "./src/*.ts"],
-	"exclude": ["node_modules", "test", "types"]
+	"include": ["./**/*.ts"],
+	"exclude": ["node_modules", "types"],
 }

package/types/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * @name Cause & Effect
- * @version 0.17.1
+ * @version 0.17.3
  * @author Esther Brunner
  */
 export { type Collection, type CollectionCallback, type CollectionSource, DerivedCollection, isCollection, TYPE_COLLECTION, } from './src/classes/collection';
@@ -15,5 +15,5 @@ export { CircularDependencyError, createError, DuplicateKeyError, type Guard, gu
 export { type MatchHandlers, match } from './src/match';
 export { type ResolveResult, resolve } from './src/resolve';
 export { createSignal, isMutableSignal, isSignal, type Signal, type SignalValues, type UnknownSignalRecord, } from './src/signal';
-export { batchSignalWrites, type Cleanup, createWatcher, emitNotification, flushPendingReactions, type Listener, type Listeners, type Notifications, notifyWatchers, subscribeActiveWatcher, trackSignalReads, type Watcher, } from './src/system';
-export { isAbortError, isAsyncFunction, isFunction, isNumber, isObjectOfType, isRecord, isRecordOrArray, isString, isSymbol, UNSET, valueString, } from './src/util';
+export { batch, type Cleanup, createWatcher, flush, notifyOf, type SignalOptions, subscribeTo, track, UNSET, untrack, type Watcher, } from './src/system';
+export { isAbortError, isAsyncFunction, isFunction, isNumber, isObjectOfType, isRecord, isRecordOrArray, isString, isSymbol, valueString, } from './src/util';

package/types/src/classes/collection.d.ts

@@ -1,5 +1,5 @@
 import type { Signal } from '../signal';
-import { type Cleanup, type Listener, type Listeners } from '../system';
+import { type SignalOptions } from '../system';
 import { type Computed } from './computed';
 import { type List } from './list';
 type CollectionSource<T extends {}> = List<T> | Collection<T>;
@@ -8,39 +8,38 @@ type Collection<T extends {}> = {
     readonly [Symbol.toStringTag]: 'Collection';
     readonly [Symbol.isConcatSpreadable]: true;
     [Symbol.iterator](): IterableIterator<Signal<T>>;
+    keys(): IterableIterator<string>;
     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;
 };
 declare const TYPE_COLLECTION: "Collection";
 declare class DerivedCollection<T extends {}, U extends {}> implements Collection<T> {
     #private;
-    constructor(source: CollectionSource<U> | (() => CollectionSource<U>), callback: CollectionCallback<T, U>);
+    constructor(source: CollectionSource<U> | (() => CollectionSource<U>), callback: CollectionCallback<T, U>, options?: SignalOptions<T[]>);
     get [Symbol.toStringTag](): 'Collection';
     get [Symbol.isConcatSpreadable](): true;
     [Symbol.iterator](): IterableIterator<Computed<T>>;
-    get length(): number;
+    keys(): IterableIterator<string>;
     get(): T[];
     at(index: number): Computed<T> | undefined;
-    keys(): IterableIterator<string>;
     byKey(key: string): Computed<T> | undefined;
     keyAt(index: number): string | undefined;
     indexOfKey(key: string): number;
-    on<K extends keyof Listeners>(type: K, listener: Listener<K>): Cleanup;
-    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: (sourceValue: T) => R, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
+    get length(): number;
 }
 /**
  * Check if a value is a collection signal
  *
- * @since 0.17.0
+ * @since 0.17.2
  * @param {unknown} value - Value to check
  * @returns {boolean} - True if value is a collection signal, false otherwise
  */
-declare const isCollection: <T extends {}, U extends {}>(value: unknown) => value is DerivedCollection<T, U>;
+declare const isCollection: <T extends {}>(value: unknown) => value is Collection<T>;
 export { type Collection, type CollectionSource, type CollectionCallback, DerivedCollection, isCollection, TYPE_COLLECTION, };

package/types/src/classes/computed.d.ts

@@ -1,7 +1,11 @@
+import { type SignalOptions } from '../system';
 type Computed<T extends {}> = {
     readonly [Symbol.toStringTag]: 'Computed';
     get(): T;
 };
+type ComputedOptions<T extends {}> = SignalOptions<T> & {
+    initialValue?: T;
+};
 type MemoCallback<T extends {} & {
     then?: undefined;
 }> = (oldValue: T) => T;
@@ -13,18 +17,14 @@ declare const TYPE_COMPUTED: "Computed";
  * Create a new memoized signal for a synchronous function.
  *
  * @since 0.17.0
+ * @param {MemoCallback<T>} callback - Callback function to compute the memoized value
+ * @param {T} [initialValue = UNSET] - Initial value of the signal
+ * @throws {InvalidCallbackError} If the callback is not an sync function
+ * @throws {InvalidSignalValueError} If the initial value is not valid
  */
 declare class Memo<T extends {}> {
     #private;
-    /**
-     * Create a new memoized signal.
-     *
-     * @param {MemoCallback<T>} callback - Callback function to compute the memoized value
-     * @param {T} [initialValue = UNSET] - Initial value of the signal
-     * @throws {InvalidCallbackError} If the callback is not an sync function
-     * @throws {InvalidSignalValueError} If the initial value is not valid
-     */
-    constructor(callback: MemoCallback<T>, initialValue?: T);
+    constructor(callback: MemoCallback<T>, options?: ComputedOptions<T>);
     get [Symbol.toStringTag](): 'Computed';
     /**
      * Return the memoized value after computing it if necessary.
@@ -39,18 +39,14 @@ declare class Memo<T extends {}> {
  * Create a new task signals that memoizes the result of an asynchronous function.
  *
  * @since 0.17.0
+ * @param {TaskCallback<T>} callback - The asynchronous function to compute the memoized value
+ * @param {T} [initialValue = UNSET] - Initial value of the signal
+ * @throws {InvalidCallbackError} If the callback is not an async function
+ * @throws {InvalidSignalValueError} If the initial value is not valid
  */
 declare class Task<T extends {}> {
     #private;
-    /**
-     * Create a new task signal for an asynchronous function.
-     *
-     * @param {TaskCallback<T>} callback - The asynchronous function to compute the memoized value
-     * @param {T} [initialValue = UNSET] - Initial value of the signal
-     * @throws {InvalidCallbackError} If the callback is not an async function
-     * @throws {InvalidSignalValueError} If the initial value is not valid
-     */
-    constructor(callback: TaskCallback<T>, initialValue?: T);
+    constructor(callback: TaskCallback<T>, options?: ComputedOptions<T>);
     get [Symbol.toStringTag](): 'Computed';
     /**
      * Return the memoized value after executing the async function if necessary.
@@ -66,8 +62,9 @@ declare class Task<T extends {}> {
  *
  * @since 0.9.0
  * @param {MemoCallback<T> | TaskCallback<T>} callback - Computation callback function
+ * @param {ComputedOptions<T>} options - Optional configuration
  */
-declare const createComputed: <T extends {}>(callback: TaskCallback<T> | MemoCallback<T>, initialValue?: T) => Task<T> | Memo<T>;
+declare const createComputed: <T extends {}>(callback: TaskCallback<T> | MemoCallback<T>, options?: ComputedOptions<T>) => Task<T> | Memo<T>;
 /**
  * Check if a value is a computed signal
  *
@@ -94,4 +91,4 @@ declare const isMemoCallback: <T extends {} & {
  * @returns {boolean} - True if value is an async callback, false otherwise
  */
 declare const isTaskCallback: <T extends {}>(value: unknown) => value is TaskCallback<T>;
-export { TYPE_COMPUTED, createComputed, isComputed, isMemoCallback, isTaskCallback, Memo, Task, type Computed, type MemoCallback, type TaskCallback, };
+export { TYPE_COMPUTED, createComputed, isComputed, isMemoCallback, isTaskCallback, Memo, Task, type Computed, type ComputedOptions, type MemoCallback, type TaskCallback, };

package/types/src/classes/list.d.ts

@@ -1,15 +1,18 @@
 import { type UnknownArray } from '../diff';
-import { type Cleanup, type Listener, type Notifications } from '../system';
+import { type SignalOptions } from '../system';
 import { DerivedCollection } from './collection';
 import { State } from './state';
 type ArrayToRecord<T extends UnknownArray> = {
     [key: string]: T extends Array<infer U extends {}> ? U : never;
 };
 type KeyConfig<T> = string | ((item: T) => string);
+type ListOptions<T extends {}> = SignalOptions<T> & {
+    keyConfig?: KeyConfig<T>;
+};
 declare const TYPE_LIST: "List";
 declare class List<T extends {}> {
     #private;
-    constructor(initialValue: T[], keyConfig?: KeyConfig<T>);
+    constructor(initialValue: T[], options?: ListOptions<T>);
     get [Symbol.toStringTag](): 'List';
     get [Symbol.isConcatSpreadable](): true;
     [Symbol.iterator](): IterableIterator<State<T>>;
@@ -26,9 +29,8 @@ declare class List<T extends {}> {
     remove(keyOrIndex: string | number): void;
     sort(compareFn?: (a: T, b: T) => number): void;
     splice(start: number, deleteCount?: number, ...items: T[]): T[];
-    on<K extends keyof Notifications>(type: K, listener: Listener<K>): Cleanup;
-    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: (sourceValue: T) => R, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>, options?: SignalOptions<R[]>): DerivedCollection<R, T>;
 }
 /**
  * Check if the provided value is a List instance
@@ -38,4 +40,4 @@ declare class List<T extends {}> {
  * @returns {boolean} - True if the value is a List instance, false otherwise
  */
 declare const isList: <T extends {}>(value: unknown) => value is List<T>;
-export { isList, List, TYPE_LIST, type ArrayToRecord, type KeyConfig };
+export { isList, List, TYPE_LIST, type ArrayToRecord, type KeyConfig, type ListOptions, };

package/types/src/classes/ref.d.ts

@@ -1,21 +1,17 @@
-import { type Guard } from '../errors';
+import { type SignalOptions } from '../system';
 declare const TYPE_REF = "Ref";
 /**
  * Create a new ref signal.
  *
  * @since 0.17.1
+ * @param {T} value - Reference to external object
+ * @param {Guard<T>} guard - Optional guard function to validate the value
+ * @throws {NullishSignalValueError} - If the value is null or undefined
+ * @throws {InvalidSignalValueError} - If the value is invalid
  */
 declare class Ref<T extends {}> {
     #private;
-    /**
-     * Create a new ref signal.
-     *
-     * @param {T} value - Reference to external object
-     * @param {Guard<T>} guard - Optional guard function to validate the value
-     * @throws {NullishSignalValueError} - If the value is null or undefined
-     * @throws {InvalidSignalValueError} - If the value is invalid
-     */
-    constructor(value: T, guard?: Guard<T>);
+    constructor(value: T, options?: SignalOptions<T>);
     get [Symbol.toStringTag](): string;
     /**
      * Get the value of the ref signal.
@@ -24,7 +20,7 @@ declare class Ref<T extends {}> {
      */
     get(): T;
     /**
-     * Notify watchers of relevant changes in the external reference
+     * Notify watchers of relevant changes in the external reference.
      */
     notify(): void;
 }
@@ -33,7 +29,7 @@ declare class Ref<T extends {}> {
  *
  * @since 0.17.1
  * @param {unknown} value - Value to check
- * @returns {boolean} - True if the value is a Ref instance, false otherwise
+ * @returns {boolean} - Whether the value is a Ref instance
  */
 declare const isRef: <T extends {}>(value: unknown) => value is Ref<T>;
 export { TYPE_REF, Ref, isRef };

package/types/src/classes/state.d.ts

@@ -1,19 +1,16 @@
+import { type SignalOptions } from '../system';
 declare const TYPE_STATE: "State";
 /**
  * Create a new state signal.
  *
  * @since 0.17.0
+ * @param {T} initialValue - Initial value of the state
+ * @throws {NullishSignalValueError} - If the initial value is null or undefined
+ * @throws {InvalidSignalValueError} - If the initial value is invalid
  */
 declare class State<T extends {}> {
     #private;
-    /**
-     * Create a new state signal.
-     *
-     * @param {T} initialValue - Initial value of the state
-     * @throws {NullishSignalValueError} - If the initial value is null or undefined
-     * @throws {InvalidSignalValueError} - If the initial value is invalid
-     */
-    constructor(initialValue: T);
+    constructor(initialValue: T, options?: SignalOptions<T>);
     get [Symbol.toStringTag](): string;
     /**
      * Get the current value of the state signal.

package/types/src/classes/store.d.ts

@@ -1,45 +1,46 @@
 import { type UnknownRecord } from '../diff';
 import { type MutableSignal } from '../signal';
-import { type Cleanup, type Listener, type Listeners } from '../system';
+import { type SignalOptions } from '../system';
 import type { List } from './list';
 import type { State } from './state';
 type Store<T extends UnknownRecord> = BaseStore<T> & {
     [K in keyof T]: T[K] extends readonly (infer U extends {})[] ? List<U> : T[K] extends UnknownRecord ? Store<T[K]> : State<T[K] & {}>;
 };
 declare const TYPE_STORE: "Store";
+/**
+ * Create a new store with the given initial value.
+ *
+ * @since 0.17.0
+ * @param {T} initialValue - The initial value of the store
+ * @throws {NullishSignalValueError} - If the initial value is null or undefined
+ * @throws {InvalidSignalValueError} - If the initial value is not an object
+ */
 declare class BaseStore<T extends UnknownRecord> {
     #private;
-    /**
-     * Create a new store with the given initial value.
-     *
-     * @param {T} initialValue - The initial value of the store
-     * @throws {NullishSignalValueError} - If the initial value is null or undefined
-     * @throws {InvalidSignalValueError} - If the initial value is not an object
-     */
-    constructor(initialValue: T);
+    constructor(initialValue: T, options?: SignalOptions<T>);
     get [Symbol.toStringTag](): 'Store';
     get [Symbol.isConcatSpreadable](): boolean;
     [Symbol.iterator](): IterableIterator<[
         string,
         MutableSignal<T[keyof T] & {}>
     ]>;
-    get(): T;
-    set(newValue: T): void;
     keys(): IterableIterator<string>;
     byKey<K extends keyof T & string>(key: K): T[K] extends readonly (infer U extends {})[] ? List<U> : T[K] extends UnknownRecord ? Store<T[K]> : T[K] extends unknown & {} ? State<T[K] & {}> : State<T[K] & {}> | undefined;
+    get(): T;
+    set(newValue: T): void;
     update(fn: (oldValue: T) => T): void;
     add<K extends keyof T & string>(key: K, value: T[K]): K;
     remove(key: string): void;
-    on<K extends keyof Omit<Listeners, 'sort'>>(type: K, listener: Listener<K>): Cleanup;
 }
 /**
  * Create a new store with deeply nested reactive properties
  *
  * @since 0.15.0
  * @param {T} initialValue - Initial object or array value of the store
+ * @param {SignalOptions<T>} options - Options for the store
  * @returns {Store<T>} - New store with reactive properties that preserves the original type T
  */
-declare const createStore: <T extends UnknownRecord>(initialValue: T) => Store<T>;
+declare const createStore: <T extends UnknownRecord>(initialValue: T, options?: SignalOptions<T>) => Store<T>;
 /**
  * Check if the provided value is a Store instance
  *

package/types/src/effect.d.ts

@@ -1,5 +1,4 @@
-import { type Cleanup } from './system';
-type MaybeCleanup = Cleanup | undefined | void;
+import { type Cleanup, type MaybeCleanup } from './system';
 type EffectCallback = (() => MaybeCleanup) | ((abort: AbortSignal) => Promise<MaybeCleanup>);
 /**
  * Define what happens when a reactive state changes

package/types/src/errors.d.ts

@@ -21,8 +21,9 @@ declare class NullishSignalValueError extends TypeError {
 declare class ReadonlySignalError extends Error {
     constructor(what: string, value: unknown);
 }
+declare function assert(condition: unknown, msg?: string): asserts condition;
 declare const createError: (reason: unknown) => Error;
 declare const validateCallback: (where: string, value: unknown, guard?: (value: unknown) => boolean) => void;
 declare const validateSignalValue: (where: string, value: unknown, guard?: (value: unknown) => boolean) => void;
 declare const guardMutableSignal: <T extends {}>(what: string, value: unknown, signal: unknown) => signal is MutableSignal<T>;
-export { type Guard, CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidCollectionSourceError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, createError, validateCallback, validateSignalValue, guardMutableSignal, };
+export { type Guard, CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidCollectionSourceError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, assert, createError, validateCallback, validateSignalValue, guardMutableSignal, };

package/types/src/signal.d.ts

@@ -6,9 +6,10 @@ import type { UnknownRecord } from './diff';
 type Signal<T extends {}> = {
     get(): T;
 };
+type UnknownSignal = Signal<unknown & {}>;
 type MutableSignal<T extends {}> = T extends readonly (infer U extends {})[] ? List<U> : T extends UnknownRecord ? Store<T> : State<T>;
 type ReadonlySignal<T extends {}> = Computed<T>;
-type UnknownSignalRecord = Record<string, Signal<unknown & {}>>;
+type UnknownSignalRecord = Record<string, UnknownSignal>;
 type SignalValues<S extends UnknownSignalRecord> = {
     [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
 };
@@ -47,4 +48,4 @@ declare function createMutableSignal<T extends {}>(value: readonly T[]): List<T>
 declare function createMutableSignal<T extends {}>(value: T[]): List<T>;
 declare function createMutableSignal<T extends UnknownRecord>(value: T): Store<T>;
 declare function createMutableSignal<T extends {}>(value: T): State<T>;
-export { createMutableSignal, createSignal, isMutableSignal, isSignal, type MutableSignal, type ReadonlySignal, type Signal, type SignalValues, type UnknownSignalRecord, };
+export { createMutableSignal, createSignal, isMutableSignal, isSignal, type MutableSignal, type ReadonlySignal, type Signal, type SignalValues, type UnknownSignal, type UnknownSignalRecord, };

package/types/src/system.d.ts

@@ -1,65 +1,78 @@
+import { type Guard } from './errors';
+import type { UnknownSignal } from './signal';
 type Cleanup = () => void;
+type MaybeCleanup = Cleanup | undefined | void;
 type Watcher = {
     (): void;
+    run(): void;
     onCleanup(cleanup: Cleanup): void;
     stop(): void;
 };
-type Notifications = {
-    add: readonly string[];
-    change: readonly string[];
-    remove: readonly string[];
-    sort: readonly string[];
-};
-type Listener<K extends keyof Notifications> = (payload: Notifications[K]) => void;
-type Listeners = {
-    [K in keyof Notifications]: Set<Listener<K>>;
+type SignalOptions<T extends unknown & {}> = {
+    guard?: Guard<T>;
+    watched?: () => void;
+    unwatched?: () => void;
 };
+declare const UNSET: any;
 /**
- * Create a watcher that can be used to observe changes to a signal
+ * Create a watcher to observe changes in signals.
  *
- * A watcher is a reaction function with onCleanup and stop methods
+ * A watcher combines push and pull reaction functions with onCleanup and stop methods
  *
- * @since 0.14.1
- * @param {() => void} react - Function to be called when the state changes
+ * @since 0.17.3
+ * @param {() => void} push - Function to be called when the state changes (push)
+ * @param {() => void} pull - Function to be called on demand from consumers (pull)
  * @returns {Watcher} - Watcher object with off and cleanup methods
  */
-declare const createWatcher: (react: () => void) => Watcher;
+declare const createWatcher: (push: () => void, pull: () => void) => Watcher;
+/**
+ * Run a function with signal reads in a non-tracking context.
+ *
+ * @param {() => void} callback - Callback
+ */
+declare const untrack: (callback: () => void) => void;
+declare const registerWatchCallbacks: (signal: UnknownSignal, watched: () => void, unwatched?: () => void) => void;
+/**
+ * Subscribe active watcher to a signal.
+ *
+ * @param {UnknownSignal} signal - Signal to subscribe to
+ * @returns {boolean} - true if the active watcher was subscribed,
+ *                      false if the watcher was already subscribed or there was no active watcher
+ */
+declare const subscribeTo: (signal: UnknownSignal) => boolean;
+declare const subscribeActiveWatcher: (watchers: Set<Watcher>) => boolean;
 /**
- * Subscribe by adding active watcher to the Set of watchers of a signal
+ * Unsubscribe all watchers from a signal so it can be garbage collected.
  *
- * @param {Set<Watcher>} watchers - Watchers of the signal
+ * @param {UnknownSignal} signal - Signal to unsubscribe from
+ * @returns {void}
  */
-declare const subscribeActiveWatcher: (watchers: Set<Watcher>) => void;
+declare const unsubscribeAllFrom: (signal: UnknownSignal) => void;
 /**
- * Notify watchers of a signal change
+ * Notify watchers of a signal change.
  *
- * @param {Set<Watcher>} watchers - Watchers of the signal
+ * @param {UnknownSignal} signal - Signal to notify watchers of
+ * @returns {boolean} - Whether any watchers were notified
  */
-declare const notifyWatchers: (watchers: Set<Watcher>) => void;
+declare const notifyOf: (signal: UnknownSignal) => boolean;
+declare const notifyWatchers: (watchers: Set<Watcher>) => boolean;
 /**
- * Flush all pending reactions of enqueued watchers
+ * Flush all pending reactions of enqueued watchers.
  */
-declare const flushPendingReactions: () => void;
+declare const flush: () => void;
 /**
- * Batch multiple signal writes
+ * Batch multiple signal writes.
  *
  * @param {() => void} callback - Function with multiple signal writes to be batched
  */
-declare const batchSignalWrites: (callback: () => void) => void;
+declare const batch: (callback: () => void) => void;
 /**
- * Run a function with signal reads in a tracking context (or temporarily untrack)
+ * Run a function with signal reads in a tracking context (or temporarily untrack).
  *
  * @param {Watcher | false} watcher - Watcher to be called when the signal changes
  *                                    or false for temporary untracking while inserting auto-hydrating DOM nodes
  *                                    that might read signals (e.g., Web Components)
  * @param {() => void} run - Function to run the computation or effect
  */
-declare const trackSignalReads: (watcher: Watcher | false, run: () => void) => void;
-/**
- * Emit a notification to listeners
- *
- * @param {Set<Listener>} listeners - Listeners to be notified
- * @param {Notifications[K]} payload - Payload to be sent to listeners
- */
-declare const emitNotification: <T extends keyof Notifications>(listeners: Set<Listener<T>>, payload: Notifications[T]) => void;
-export { type Cleanup, type Watcher, type Notifications, type Listener, type Listeners, createWatcher, subscribeActiveWatcher, notifyWatchers, flushPendingReactions, batchSignalWrites, trackSignalReads, emitNotification, };
+declare const track: (watcher: Watcher | false, run: () => void) => void;
+export { type Cleanup, type MaybeCleanup, type Watcher, type SignalOptions, UNSET, createWatcher, registerWatchCallbacks, subscribeTo, subscribeActiveWatcher, unsubscribeAllFrom, notifyOf, notifyWatchers, flush, batch, track, untrack, };

package/types/src/util.d.ts

@@ -1,4 +1,3 @@
-declare const UNSET: any;
 declare const isString: (value: unknown) => value is string;
 declare const isNumber: (value: unknown) => value is number;
 declare const isSymbol: (value: unknown) => value is symbol;
@@ -15,4 +14,4 @@ declare const isUniformArray: <T>(value: unknown, guard?: (item: T) => item is T
 declare const hasMethod: <T extends object & Record<string, (...args: unknown[]) => unknown>>(obj: T, methodName: string) => obj is T & Record<string, (...args: unknown[]) => unknown>;
 declare const isAbortError: (error: unknown) => boolean;
 declare const valueString: (value: unknown) => string;
-export { UNSET, isString, isNumber, isSymbol, isFunction, isAsyncFunction, isSyncFunction, isNonNullObject, isObjectOfType, isRecord, isRecordOrArray, isUniformArray, hasMethod, isAbortError, valueString, };
+export { isString, isNumber, isSymbol, isFunction, isAsyncFunction, isSyncFunction, isNonNullObject, isObjectOfType, isRecord, isRecordOrArray, isUniformArray, hasMethod, isAbortError, valueString, };