mutts 1.0.0

package/dist/reactive.d.ts

@@ -0,0 +1,114 @@
+import { LegacyClassDecorator, ModernClassDecorator, LegacyPropertyDecorator, ModernGetterDecorator, ModernAccessorDecorator, GenericClassDecorator } from './decorator.js';
+
+type DependencyFunction = <T>(cb: () => T) => T;
+type ScopedCallback = () => void;
+type PropEvolution = {
+    type: 'set' | 'del' | 'add';
+    prop: any;
+};
+type BunchEvolution = {
+    type: 'bunch';
+    method: string;
+};
+type Evolution = PropEvolution | BunchEvolution;
+type State = {
+    evolution: Evolution;
+    next: State;
+} | {};
+declare const profileInfo: any;
+declare class ReactiveError extends Error {
+    constructor(message: string);
+}
+/**
+ * Options for the reactive system, can be configured at runtime
+ */
+declare const options: {
+    /**
+     * Debug purpose: called when an effect is entered
+     * @param effect - The effect that is entered
+     */
+    enter: (effect: Function) => void;
+    /**
+     * Debug purpose: called when an effect is left
+     * @param effect - The effect that is left
+     */
+    leave: (effect: Function) => void;
+    /**
+     * Debug purpose: called when an effect is chained
+     * @param target - The effect that is being triggered
+     * @param caller - The effect that is calling the target
+     */
+    chain: (target: Function, caller?: Function) => void;
+    /**
+     * Debug purpose: maximum effect chain (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 100
+     */
+    maxEffectChain: number;
+    /**
+     * Maximum depth for deep watching traversal
+     * Used to prevent infinite recursion in circular references
+     * @default 100
+     */
+    maxDeepWatchDepth: number;
+    /**
+     * Only react on instance members modification (not inherited properties)
+     * For instance, do not track class methods
+     * @default true
+     */
+    instanceMembers: boolean;
+    warn: (...args: any[]) => void;
+};
+declare function getState(obj: any): State;
+declare class ReactiveBase {
+    constructor();
+}
+declare function reactiveObject<T>(anyTarget: T): T;
+declare const reactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
+declare function unwrap<T>(proxy: T): T;
+declare function isReactive(obj: any): boolean;
+declare function untracked(fn: () => ScopedCallback | undefined | void): void;
+/**
+ * @param fn - The effect function to run - provides the cleaner
+ * @returns The cleanup function
+ */
+declare function effect<Args extends any[]>(fn: (dep: DependencyFunction, ...args: Args) => ScopedCallback | undefined | void, ...args: Args): ScopedCallback;
+/**
+ * Set of functions to test if an object is immutable
+ */
+declare const immutables: Set<(tested: any) => boolean>;
+/**
+ * Check if an object is marked as non-reactive (for testing purposes)
+ * @param obj - The object to check
+ * @returns true if the object is marked as non-reactive
+ */
+declare function isNonReactive(obj: any): boolean;
+
+/**
+ * When used in a computed property computation, it will register the callback to be called when the computed property is invalidated
+ * @param cb - The callback to register
+ * @param warn - Whether to warn if used outside of a computed property
+ */
+declare function invalidateComputed(cb: () => void, warn?: boolean): void;
+type ComputedFunction<T> = (dep: DependencyFunction) => T;
+/**
+ * Get the cached value of a computed function - cache is invalidated when the dependencies change
+ */
+declare const computed: LegacyPropertyDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & (<T>(getter: ComputedFunction<T>) => T);
+interface WatchOptions {
+    immediate?: boolean;
+    deep?: boolean;
+}
+declare function watch<T>(value: (dep: DependencyFunction) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep?: false;
+}): ScopedCallback;
+declare function watch<T extends object | any[]>(value: (dep: DependencyFunction) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep: true;
+}): ScopedCallback;
+declare function watch<T extends object | any[]>(value: T, changed: (value: T) => void, options?: WatchOptions): ScopedCallback;
+declare function unreactiveApplication<T extends object>(...args: (keyof T)[]): GenericClassDecorator<T>;
+declare function unreactiveApplication<T extends object>(obj: T): T;
+declare const unreactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof unreactiveApplication;
+
+export { ReactiveBase, ReactiveError, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, unreactive, untracked, unwrap, watch };
+export type { ScopedCallback };