@zeix/cause-effect 0.17.3 → 0.18.1

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

@@ -1,35 +0,0 @@
-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;
-    constructor(value: T, options?: SignalOptions<T>);
-    get [Symbol.toStringTag](): string;
-    /**
-     * Get the value of the ref signal.
-     *
-     * @returns {T} - Object reference
-     */
-    get(): T;
-    /**
-     * Notify watchers of relevant changes in the external reference.
-     */
-    notify(): void;
-}
-/**
- * Check if the provided value is a Ref instance
- *
- * @since 0.17.1
- * @param {unknown} value - Value to check
- * @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,49 +0,0 @@
-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;
-    constructor(initialValue: T, options?: SignalOptions<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

@@ -1,52 +0,0 @@
-import { type UnknownRecord } from '../diff';
-import { type MutableSignal } from '../signal';
-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;
-    constructor(initialValue: T, options?: SignalOptions<T>);
-    get [Symbol.toStringTag](): 'Store';
-    get [Symbol.isConcatSpreadable](): boolean;
-    [Symbol.iterator](): IterableIterator<[
-        string,
-        MutableSignal<T[keyof T] & {}>
-    ]>;
-    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;
-}
-/**
- * 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, options?: SignalOptions<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,28 +0,0 @@
-type UnknownRecord = Record<string, unknown>;
-type UnknownArray = ReadonlyArray<unknown & {}>;
-type DiffResult = {
-    changed: boolean;
-    add: UnknownRecord;
-    change: UnknownRecord;
-    remove: UnknownRecord;
-};
-/**
- * Checks if two values are equal with cycle detection
- *
- * @since 0.15.0
- * @param {T} a - First value to compare
- * @param {T} b - Second value to compare
- * @param {WeakSet<object>} visited - Set to track visited objects for cycle detection
- * @returns {boolean} Whether the two values are equal
- */
-declare const isEqual: <T>(a: T, b: T, visited?: WeakSet<object>) => boolean;
-/**
- * Compares two records and returns a result object containing the differences.
- *
- * @since 0.15.0
- * @param {T} oldObj - The old record to compare
- * @param {T} newObj - The new record to compare
- * @returns {DiffResult} The result of the comparison
- */
-declare const diff: <T extends UnknownRecord>(oldObj: T, newObj: T) => DiffResult;
-export { type DiffResult, diff, isEqual, type UnknownRecord, type UnknownArray };

package/types/src/effect.d.ts

@@ -1,15 +0,0 @@
-import { type Cleanup, type MaybeCleanup } from './system';
-type EffectCallback = (() => MaybeCleanup) | ((abort: AbortSignal) => Promise<MaybeCleanup>);
-/**
- * Define what happens when a reactive state changes
- *
- * The callback can be synchronous or asynchronous. Async callbacks receive
- * an AbortSignal parameter, which is automatically aborted when the effect
- * re-runs or is cleaned up, preventing stale async operations.
- *
- * @since 0.1.0
- * @param {EffectCallback} callback - Synchronous or asynchronous effect callback
- * @returns {Cleanup} - Cleanup function for the effect
- */
-declare const createEffect: (callback: EffectCallback) => Cleanup;
-export { type MaybeCleanup, type EffectCallback, createEffect };

package/types/src/match.d.ts

@@ -1,21 +0,0 @@
-import type { ResolveResult } from './resolve';
-import type { SignalValues, UnknownSignalRecord } from './signal';
-type MatchHandlers<S extends UnknownSignalRecord> = {
-    ok: (values: SignalValues<S>) => void;
-    err?: (errors: readonly Error[]) => void;
-    nil?: () => void;
-};
-/**
- * Match on resolve result and call appropriate handler for side effects
- *
- * This is a utility function for those who prefer the handler pattern.
- * All handlers are for side effects only and return void. If you need
- * cleanup logic, use a hoisted let variable in your effect.
- *
- * @since 0.15.0
- * @param {ResolveResult<S>} result - Result from resolve()
- * @param {MatchHandlers<S>} handlers - Handlers for different states (side effects only)
- * @returns {void} - Always returns void
- */
-declare function match<S extends UnknownSignalRecord>(result: ResolveResult<S>, handlers: MatchHandlers<S>): void;
-export { match, type MatchHandlers };

package/types/src/resolve.d.ts

@@ -1,29 +0,0 @@
-import type { SignalValues, UnknownSignalRecord } from './signal';
-type ResolveResult<S extends UnknownSignalRecord> = {
-    ok: true;
-    values: SignalValues<S>;
-    errors?: never;
-    pending?: never;
-} | {
-    ok: false;
-    errors: readonly Error[];
-    values?: never;
-    pending?: never;
-} | {
-    ok: false;
-    pending: true;
-    values?: never;
-    errors?: never;
-};
-/**
- * Resolve signal values with perfect type inference
- *
- * Always returns a discriminated union result, regardless of whether
- * handlers are provided or not. This ensures a predictable API.
- *
- * @since 0.15.0
- * @param {S} signals - Signals to resolve
- * @returns {ResolveResult<S>} - Discriminated union result
- */
-declare function resolve<S extends UnknownSignalRecord>(signals: S): ResolveResult<S>;
-export { resolve, type ResolveResult };

package/types/src/system.d.ts

@@ -1,78 +0,0 @@
-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 SignalOptions<T extends unknown & {}> = {
-    guard?: Guard<T>;
-    watched?: () => void;
-    unwatched?: () => void;
-};
-declare const UNSET: any;
-/**
- * Create a watcher to observe changes in signals.
- *
- * A watcher combines push and pull reaction functions with onCleanup and stop methods
- *
- * @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: (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;
-/**
- * Unsubscribe all watchers from a signal so it can be garbage collected.
- *
- * @param {UnknownSignal} signal - Signal to unsubscribe from
- * @returns {void}
- */
-declare const unsubscribeAllFrom: (signal: UnknownSignal) => void;
-/**
- * Notify watchers of a signal change.
- *
- * @param {UnknownSignal} signal - Signal to notify watchers of
- * @returns {boolean} - Whether any watchers were notified
- */
-declare const notifyOf: (signal: UnknownSignal) => boolean;
-declare const notifyWatchers: (watchers: Set<Watcher>) => boolean;
-/**
- * Flush all pending reactions of enqueued watchers.
- */
-declare const flush: () => void;
-/**
- * Batch multiple signal writes.
- *
- * @param {() => void} callback - Function with multiple signal writes to be batched
- */
-declare const batch: (callback: () => void) => void;
-/**
- * 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 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, };