@zeix/cause-effect 0.16.1 → 0.17.0

package/types/index.d.ts

@@ -1,16 +1,18 @@
 /**
  * @name Cause & Effect
- * @version 0.16.1
+ * @version 0.17.0
  * @author Esther Brunner
  */
-export { type Computed, type ComputedCallback, createComputed, isComputed, isComputedCallback, TYPE_COMPUTED, } from './src/computed';
-export { type DiffResult, diff, isEqual, type PartialRecord, type UnknownArray, type UnknownRecord, } from './src/diff';
+export { Collection, type CollectionCallback, isCollection, TYPE_COLLECTION, } from './src/classes/collection';
+export { type Computed, createComputed, isComputed, isMemoCallback, isTaskCallback, Memo, type MemoCallback, Task, type TaskCallback, TYPE_COMPUTED, } from './src/classes/computed';
+export { type ArrayToRecord, isList, type KeyConfig, List, TYPE_LIST, } from './src/classes/list';
+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 UnknownArray, type UnknownRecord, } from './src/diff';
 export { createEffect, type EffectCallback, type MaybeCleanup, } from './src/effect';
-export { CircularDependencyError, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, StoreKeyExistsError, StoreKeyRangeError, StoreKeyReadonlyError, } from './src/errors';
+export { CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, } from './src/errors';
 export { type MatchHandlers, match } from './src/match';
 export { type ResolveResult, resolve } from './src/resolve';
-export { 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, type Cleanup, createWatcher, flush, notify, observe, subscribe, type Watcher, } from './src/system';
+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, toError, UNSET, valueString, } from './src/util';

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

@@ -0,0 +1,32 @@
+import { type Cleanup, type Listener, type Listeners } from '../system';
+import { type Computed } from './computed';
+import { type List } from './list';
+type CollectionSource<T extends {}> = List<T> | Collection<T, any>;
+type CollectionCallback<T extends {}, U extends {}> = ((sourceValue: U) => T) | ((sourceValue: U, abort: AbortSignal) => Promise<T>);
+declare const TYPE_COLLECTION: "Collection";
+declare class Collection<T extends {}, U extends {}> {
+    #private;
+    constructor(source: CollectionSource<U> | (() => CollectionSource<U>), callback: CollectionCallback<T, U>);
+    get [Symbol.toStringTag](): 'Collection';
+    get [Symbol.isConcatSpreadable](): boolean;
+    [Symbol.iterator](): IterableIterator<Computed<T>>;
+    get length(): number;
+    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): Collection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>): Collection<R, T>;
+}
+/**
+ * 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
+ */
+declare const isCollection: <T extends {}, U extends {}>(value: unknown) => value is Collection<T, U>;
+export { Collection, type CollectionSource, type CollectionCallback, isCollection, TYPE_COLLECTION, };

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

@@ -0,0 +1,15 @@
+import type { DiffResult, UnknownRecord } from '../diff';
+import type { Signal } from '../signal';
+import { type Cleanup, type Listener, type Listeners } from '../system';
+type CompositeListeners = Pick<Listeners, 'add' | 'change' | 'remove'>;
+declare class Composite<T extends UnknownRecord, S extends Signal<T[keyof T] & {}>> {
+    #private;
+    signals: Map<string, S>;
+    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);
+    add<K extends keyof T & string>(key: K, value: T[K]): boolean;
+    remove<K extends keyof T & string>(key: K): boolean;
+    change(changes: DiffResult, initialRun?: boolean): boolean;
+    clear(): boolean;
+    on<K extends keyof CompositeListeners>(type: K, listener: Listener<K>): Cleanup;
+}
+export { Composite, type CompositeListeners };

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

@@ -0,0 +1,97 @@
+type Computed<T extends {}> = {
+    readonly [Symbol.toStringTag]: 'Computed';
+    get(): T;
+};
+type MemoCallback<T extends {} & {
+    then?: undefined;
+}> = (oldValue: T) => T;
+type TaskCallback<T extends {} & {
+    then?: undefined;
+}> = (oldValue: T, abort: AbortSignal) => Promise<T>;
+declare const TYPE_COMPUTED: "Computed";
+/**
+ * Create a new memoized signal for a synchronous function.
+ *
+ * @since 0.17.0
+ */
+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);
+    get [Symbol.toStringTag](): 'Computed';
+    /**
+     * Return the memoized value after computing it if necessary.
+     *
+     * @returns {T}
+     * @throws {CircularDependencyError} If a circular dependency is detected
+     * @throws {Error} If an error occurs during computation
+     */
+    get(): T;
+}
+/**
+ * Create a new task signals that memoizes the result of an asynchronous function.
+ *
+ * @since 0.17.0
+ */
+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);
+    get [Symbol.toStringTag](): 'Computed';
+    /**
+     * Return the memoized value after executing the async function if necessary.
+     *
+     * @returns {T}
+     * @throws {CircularDependencyError} If a circular dependency is detected
+     * @throws {Error} If an error occurs during computation
+     */
+    get(): T;
+}
+/**
+ * Create a derived signal from existing signals
+ *
+ * @since 0.9.0
+ * @param {MemoCallback<T> | TaskCallback<T>} callback - Computation callback function
+ */
+declare const createComputed: <T extends {}>(callback: TaskCallback<T> | MemoCallback<T>, initialValue?: T) => Task<T> | Memo<T>;
+/**
+ * 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 signal, false otherwise
+ */
+declare const isComputed: <T extends {}>(value: unknown) => value is Memo<T>;
+/**
+ * Check if the provided value is a callback that may be used as input for createSignal() to derive a computed state
+ *
+ * @since 0.12.0
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - True if value is a sync callback, false otherwise
+ */
+declare const isMemoCallback: <T extends {} & {
+    then?: undefined;
+}>(value: unknown) => value is MemoCallback<T>;
+/**
+ * Check if the provided value is a callback that may be used as input for createSignal() to derive a computed state
+ *
+ * @since 0.17.0
+ * @param {unknown} value - Value to check
+ * @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, };

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

@@ -0,0 +1,41 @@
+import { type UnknownArray } from '../diff';
+import { type Cleanup, type Listener, type Notifications } from '../system';
+import { Collection } 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);
+declare const TYPE_LIST: "List";
+declare class List<T extends {}> {
+    #private;
+    constructor(initialValue: T[], keyConfig?: KeyConfig<T>);
+    get [Symbol.toStringTag](): 'List';
+    get [Symbol.isConcatSpreadable](): boolean;
+    [Symbol.iterator](): IterableIterator<State<T>>;
+    get length(): number;
+    get(): T[];
+    set(newValue: T[]): void;
+    update(fn: (oldValue: T[]) => T[]): void;
+    at(index: number): State<T> | undefined;
+    keys(): IterableIterator<string>;
+    byKey(key: string): State<T> | undefined;
+    keyAt(index: number): string | undefined;
+    indexOfKey(key: string): number;
+    add(value: T): string;
+    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): Collection<R, T>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>): Collection<R, T>;
+}
+/**
+ * Check if the provided value is a List instance
+ *
+ * @since 0.15.0
+ * @param {unknown} value - Value to check
+ * @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 };

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

@@ -0,0 +1,52 @@
+declare const TYPE_STATE: "State";
+/**
+ * Create a new state signal.
+ *
+ * @since 0.17.0
+ */
+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);
+    get [Symbol.toStringTag](): string;
+    /**
+     * Get the current value of the state signal.
+     *
+     * @returns {T} - Current value of the state
+     */
+    get(): T;
+    /**
+     * Set the value of the state signal.
+     *
+     * @param {T} newValue - New value of the state
+     * @returns {void}
+     * @throws {NullishSignalValueError} - If the initial value is null or undefined
+     * @throws {InvalidSignalValueError} - If the initial value is invalid
+     */
+    set(newValue: T): void;
+    /**
+     * Update the value of the state signal.
+     *
+     * @param {Function} updater - Function that takes the current value and returns the new value
+     * @returns {void}
+     * @throws {InvalidCallbackError} - If the updater function is not a function
+     * @throws {NullishSignalValueError} - If the initial value is null or undefined
+     * @throws {InvalidSignalValueError} - If the initial value is invalid
+     */
+    update(updater: (oldValue: T) => T): void;
+}
+/**
+ * Check if the provided value is a State instance
+ *
+ * @since 0.9.0
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - True if the value is a State instance, false otherwise
+ */
+declare const isState: <T extends {}>(value: unknown) => value is State<T>;
+export { TYPE_STATE, isState, State };

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

@@ -0,0 +1,51 @@
+import { type UnknownRecord } from '../diff';
+import { type MutableSignal } from '../signal';
+import { type Cleanup, type Listener, type Listeners } 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";
+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);
+    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;
+    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
+ * @returns {Store<T>} - New store with reactive properties that preserves the original type T
+ */
+declare const createStore: <T extends UnknownRecord>(initialValue: T) => Store<T>;
+/**
+ * Check if the provided value is a Store instance
+ *
+ * @since 0.15.0
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - True if the value is a Store instance, false otherwise
+ */
+declare const isStore: <T extends UnknownRecord>(value: unknown) => value is BaseStore<T>;
+export { createStore, isStore, BaseStore, TYPE_STORE, type Store };

package/types/src/diff.d.ts

@@ -1,14 +1,10 @@
-type UnknownRecord = Record<string, unknown & {}>;
+type UnknownRecord = Record<string, unknown>;
 type UnknownArray = ReadonlyArray<unknown & {}>;
-type ArrayToRecord<T extends UnknownArray> = {
-    [key: string]: T extends Array<infer U extends {}> ? U : never;
-};
-type PartialRecord<T> = T extends UnknownArray ? Partial<ArrayToRecord<T>> : Partial<T>;
-type DiffResult<T extends UnknownRecord | UnknownArray = UnknownRecord> = {
+type DiffResult = {
     changed: boolean;
-    add: PartialRecord<T>;
-    change: PartialRecord<T>;
-    remove: PartialRecord<T>;
+    add: UnknownRecord;
+    change: UnknownRecord;
+    remove: UnknownRecord;
 };
 /**
  * Checks if two values are equal with cycle detection
@@ -26,7 +22,7 @@ declare const isEqual: <T>(a: T, b: T, visited?: WeakSet<object>) => boolean;
  * @since 0.15.0
  * @param {T} oldObj - The old record to compare
  * @param {T} newObj - The new record to compare
- * @returns {DiffResult<T>} The result of the comparison
+ * @returns {DiffResult} The result of the comparison
  */
-declare const diff: <T extends UnknownRecord | UnknownArray>(oldObj: T extends UnknownArray ? ArrayToRecord<T> : T, newObj: T extends UnknownArray ? ArrayToRecord<T> : T) => DiffResult<T>;
-export { type ArrayToRecord, type DiffResult, diff, isEqual, type UnknownRecord, type UnknownArray, type PartialRecord, };
+declare const diff: <T extends UnknownRecord>(oldObj: T, newObj: T) => DiffResult;
+export { type DiffResult, diff, isEqual, type UnknownRecord, type UnknownArray };

package/types/src/errors.d.ts

@@ -1,22 +1,23 @@
+import { type MutableSignal } from './signal';
 declare class CircularDependencyError extends Error {
     constructor(where: string);
 }
+declare class DuplicateKeyError extends Error {
+    constructor(where: string, key: string, value?: unknown);
+}
 declare class InvalidCallbackError extends TypeError {
-    constructor(where: string, value: string);
+    constructor(where: string, value: unknown);
 }
 declare class InvalidSignalValueError extends TypeError {
-    constructor(where: string, value: string);
+    constructor(where: string, value: unknown);
 }
 declare class NullishSignalValueError extends TypeError {
     constructor(where: string);
 }
-declare class StoreKeyExistsError extends Error {
-    constructor(key: string, value: string);
-}
-declare class StoreKeyRangeError extends RangeError {
-    constructor(index: number);
-}
-declare class StoreKeyReadonlyError extends Error {
-    constructor(key: string, value: string);
+declare class ReadonlySignalError extends Error {
+    constructor(what: string, value: unknown);
 }
-export { CircularDependencyError, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, StoreKeyExistsError, StoreKeyRangeError, StoreKeyReadonlyError, };
+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 { CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, validateCallback, validateSignalValue, guardMutableSignal, };

package/types/src/signal.d.ts

@@ -1,9 +1,13 @@
-import { type Computed, type ComputedCallback } from './computed';
-import { type State } from './state';
-import { type Store } from './store';
+import { type Computed } from './classes/computed';
+import { List } from './classes/list';
+import { State } from './classes/state';
+import { type Store } from './classes/store';
+import type { UnknownRecord } from './diff';
 type Signal<T extends {}> = {
     get(): T;
 };
+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 SignalValues<S extends UnknownSignalRecord> = {
     [K in keyof S]: S[K] extends Signal<infer T> ? T : never;
@@ -17,21 +21,30 @@ type SignalValues<S extends UnknownSignalRecord> = {
  */
 declare const isSignal: <T extends {}>(value: unknown) => value is Signal<T>;
 /**
- * Check whether a value is a State or Store
+ * Check whether a value is a State, Store, or List
  *
  * @since 0.15.2
- * @param {unknown} value - value to check
- * @returns {boolean} - true if value is a State or Store, false otherwise
+ * @param {unknown} value - Value to check
+ * @returns {boolean} - True if value is a State, Store, or List, false otherwise
  */
-declare const isMutableSignal: <T extends {}>(value: unknown) => value is State<T> | Store<T>;
+declare const isMutableSignal: (value: unknown) => value is MutableSignal<unknown & {}>;
 /**
- * Convert a value to a Signal if it's not already a Signal
+ * Convert a value to a Signal.
  *
  * @since 0.9.6
- * @param {T} value - value to convert
- * @returns {Signal<T>} - Signal instance
  */
-declare function toSignal<T extends {}>(value: T): T extends Store<infer U> ? Store<U> : T extends State<infer U> ? State<U> : T extends Computed<infer U> ? Computed<U> : T extends Signal<infer U> ? Signal<U> : T extends ReadonlyArray<infer U extends {}> ? Store<U[]> : T extends Record<string, unknown & {}> ? Store<{
-    [K in keyof T]: T[K];
-}> : T extends ComputedCallback<infer U extends {}> ? Computed<U> : State<T>;
-export { type Signal, type UnknownSignalRecord, type SignalValues, isSignal, isMutableSignal, toSignal, };
+declare function createSignal<T extends {}>(value: readonly T[]): List<T>;
+declare function createSignal<T extends {}>(value: T[]): List<T>;
+declare function createSignal<T extends UnknownRecord>(value: T): Store<T>;
+declare function createSignal<T extends {}>(value: () => T): Computed<T>;
+declare function createSignal<T extends {}>(value: T): State<T>;
+/**
+ * Convert a value to a MutableSignal.
+ *
+ * @since 0.17.0
+ */
+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, };

package/types/src/system.d.ts

@@ -1,44 +1,65 @@
 type Cleanup = () => void;
 type Watcher = {
     (): void;
-    unwatch(cleanup: Cleanup): void;
-    cleanup(): 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>>;
 };
 /**
  * Create a watcher that can be used to observe changes to a signal
  *
+ * A watcher is a reaction function with onCleanup and stop methods
+ *
  * @since 0.14.1
- * @param {() => void} watch - Function to be called when the state changes
+ * @param {() => void} react - Function to be called when the state changes
  * @returns {Watcher} - Watcher object with off and cleanup methods
  */
-declare const createWatcher: (watch: () => void) => Watcher;
+declare const createWatcher: (react: () => void) => Watcher;
 /**
- * Add active watcher to the Set of watchers
+ * Subscribe by adding active watcher to the Set of watchers of a signal
  *
- * @param {Set<Watcher>} watchers - watchers of the signal
+ * @param {Set<Watcher>} watchers - Watchers of the signal
  */
-declare const subscribe: (watchers: Set<Watcher>) => void;
+declare const subscribeActiveWatcher: (watchers: Set<Watcher>) => void;
 /**
- * Add watchers to the pending set of change notifications
+ * Notify watchers of a signal change
  *
- * @param {Set<Watcher>} watchers - watchers of the signal
+ * @param {Set<Watcher>} watchers - Watchers of the signal
  */
-declare const notify: (watchers: Set<Watcher>) => void;
+declare const notifyWatchers: (watchers: Set<Watcher>) => void;
 /**
- * Flush all pending changes to notify watchers
+ * Flush all pending reactions of enqueued watchers
+ */
+declare const flushPendingReactions: () => void;
+/**
+ * Batch multiple signal writes
+ *
+ * @param {() => void} callback - Function with multiple signal writes to be batched
  */
-declare const flush: () => void;
+declare const batchSignalWrites: (callback: () => void) => void;
 /**
- * Batch multiple changes in a single signal graph and DOM update cycle
+ * Run a function with signal reads in a tracking context (or temporarily untrack)
  *
- * @param {() => void} fn - function with multiple signal writes to be batched
+ * @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 batch: (fn: () => void) => void;
+declare const trackSignalReads: (watcher: Watcher | false, run: () => void) => void;
 /**
- * Run a function in a reactive context
+ * Emit a notification to listeners
  *
- * @param {() => void} run - function to run the computation or effect
- * @param {Watcher} watcher - function to be called when the state changes or undefined for temporary unwatching while inserting auto-hydrating DOM nodes that might read signals (e.g., web components)
+ * @param {Set<Listener>} listeners - Listeners to be notified
+ * @param {Notifications[K]} payload - Payload to be sent to listeners
  */
-declare const observe: (run: () => void, watcher?: Watcher) => void;
-export { type Cleanup, type Watcher, subscribe, notify, flush, batch, createWatcher, observe, };
+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, };

package/types/src/util.d.ts

@@ -4,13 +4,16 @@ declare const isNumber: (value: unknown) => value is number;
 declare const isSymbol: (value: unknown) => value is symbol;
 declare const isFunction: <T>(fn: unknown) => fn is (...args: unknown[]) => T;
 declare const isAsyncFunction: <T>(fn: unknown) => fn is (...args: unknown[]) => Promise<T>;
+declare const isSyncFunction: <T extends unknown & {
+    then?: undefined;
+}>(fn: unknown) => fn is (...args: unknown[]) => T;
+declare const isNonNullObject: (value: unknown) => value is NonNullable<object>;
 declare const isObjectOfType: <T>(value: unknown, type: string) => value is T;
 declare const isRecord: <T extends Record<string, unknown>>(value: unknown) => value is T;
 declare const isRecordOrArray: <T extends Record<string | number, unknown> | ReadonlyArray<unknown>>(value: unknown) => value is T;
+declare const isUniformArray: <T>(value: unknown, guard?: (item: T) => item is T & {}) => value 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 toError: (reason: unknown) => Error;
-declare const arrayToRecord: <T>(array: T[]) => Record<string, T>;
-declare const recordToArray: <T>(record: Record<string | number, T>) => Record<string, T> | T[];
 declare const valueString: (value: unknown) => string;
-export { UNSET, isString, isNumber, isSymbol, isFunction, isAsyncFunction, isObjectOfType, isRecord, isRecordOrArray, hasMethod, isAbortError, toError, arrayToRecord, recordToArray, valueString, };
+export { UNSET, isString, isNumber, isSymbol, isFunction, isAsyncFunction, isSyncFunction, isNonNullObject, isObjectOfType, isRecord, isRecordOrArray, isUniformArray, hasMethod, isAbortError, toError, valueString, };