mutts 1.0.7 → 1.0.8

package/dist/reactive/deep-watch.d.ts

@@ -0,0 +1,19 @@
+export { addBackReference, bubbleUpChange, deepWatchers, effectToDeepWatchedObjects, needsBackReferences, objectParents, objectsWithDeepWatchers, removeBackReference, } from './deep-watch-state';
+/**
+ * Deep watch an object and all its nested properties
+ * @param target - The object to watch deeply
+ * @param callback - The callback to call when any nested property changes
+ * @param options - Options for the deep watch
+ * @returns A cleanup function to stop watching
+ */
+/**
+ * Sets up deep watching for an object, tracking all nested property changes
+ * @param target - The object to watch
+ * @param callback - The callback to call when changes occur
+ * @param options - Options for deep watching
+ * @returns A cleanup function to stop deep watching
+ */
+export declare function deepWatch<T extends object>(target: T, callback: (value: T) => void, { immediate }?: {
+    immediate?: boolean;
+}): (() => void) | undefined;
+//# sourceMappingURL=deep-watch.d.ts.map

package/dist/reactive/deep-watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-watch.d.ts","sourceRoot":"","sources":["../../src/reactive/deep-watch.ts"],"names":[],"mappings":"AAeA,OAAO,EACN,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,0BAA0B,EAC1B,mBAAmB,EACnB,aAAa,EACb,uBAAuB,EACvB,mBAAmB,GACnB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;GAMG;AACH;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EACzC,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC5B,EAAE,SAAiB,EAAE;;CAAK,GACxB,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CA2H1B"}

package/dist/reactive/effect-context.d.ts

@@ -0,0 +1,7 @@
+import { ZoneAggregator, ZoneHistory } from '../zone';
+import { type ScopedCallback } from './types';
+export declare const effectHistory: ZoneHistory<ScopedCallback>;
+export declare const effectAggregator: ZoneAggregator;
+export declare function isRunning(effect: ScopedCallback): boolean;
+export declare function getActiveEffect(): ScopedCallback;
+//# sourceMappingURL=effect-context.d.ts.map

package/dist/reactive/effect-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-context.d.ts","sourceRoot":"","sources":["../../src/reactive/effect-context.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAEhE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C,eAAO,MAAM,aAAa,6BAA0D,CAAA;AAGpF,eAAO,MAAM,gBAAgB,gBAAqE,CAAA;AAElG,wBAAgB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAGzD;AAED,wBAAgB,eAAe,mBAE9B"}

package/dist/reactive/effects.d.ts

@@ -0,0 +1,151 @@
+import { cleanup as cleanupSymbol, type DependencyAccess, type EffectOptions, type Evolution, type ScopedCallback, stopped } from './types';
+type EffectTracking = (obj: any, evolution: Evolution, prop: any) => void;
+export interface ActivationRecord {
+    effect: ScopedCallback;
+    obj: any;
+    evolution: Evolution;
+    prop: any;
+    batchId: number;
+}
+export declare const activationLog: Omit<ActivationRecord, 'batchId'>[];
+export declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
+export declare function recordActivation(effect: ScopedCallback, obj: any, evolution: Evolution, prop: any): void;
+/**
+ * Registers a debug callback that is called when the current effect is triggered by a dependency change
+ *
+ * This function is useful for debugging purposes as it pin-points exactly which reactive property
+ * change triggered the effect. The callback receives information about:
+ * - The object that changed
+ * - The type of change (evolution)
+ * - The specific property that changed
+ *
+ * **Note:** The tracker callback is automatically removed after being called once. If you need
+ * to track multiple triggers, call `trackEffect` again within the effect.
+ *
+ * @param onTouch - Callback function that receives (obj, evolution, prop) when the effect is triggered
+ * @throws {Error} If called outside of an effect context
+ *
+ * @example
+ * ```typescript
+ * const state = reactive({ count: 0, name: 'John' })
+ *
+ * effect(() => {
+ *   // Register a tracker to see what triggers this effect
+ *   trackEffect((obj, evolution, prop) => {
+ *     console.log(`Effect triggered by:`, {
+ *       object: obj,
+ *       change: evolution.type,
+ *       property: prop
+ *     })
+ *   })
+ *
+ *   // Access reactive properties
+ *   console.log(state.count, state.name)
+ * })
+ *
+ * state.count = 5
+ * // Logs: Effect triggered by: { object: state, change: 'set', property: 'count' }
+ * ```
+ */
+export declare function trackEffect(onTouch: EffectTracking): void;
+declare const effectTrackers: WeakMap<ScopedCallback, Set<EffectTracking>>;
+export declare const opaqueEffects: WeakSet<ScopedCallback>;
+export declare const effectCreationStacks: WeakMap<Function, string>;
+export declare function hasBatched(effect: ScopedCallback): boolean;
+/**
+ * Adds a cleanup function to be called when the current batch of effects completes
+ * @param cleanup - The cleanup function to add
+ */
+export declare function addBatchCleanup(cleanup: ScopedCallback): void;
+/**
+ * Semantic alias for `addBatchCleanup` - defers work to the end of the current reactive batch.
+ *
+ * Use this when an effect needs to perform an action that would modify state the effect depends on,
+ * which would create a reactive cycle. The deferred callback runs after all effects complete.
+ *
+ * @param callback - The callback to defer until after the current batch completes
+ *
+ * @example
+ * ```typescript
+ * effect(() => {
+ *   processData()
+ *
+ *   // Defer to avoid cycle (createMovement modifies state this effect reads)
+ *   defer(() => {
+ *     createMovement(data)
+ *   })
+ * })
+ * ```
+ */
+export declare const defer: typeof addBatchCleanup;
+export declare function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'immediate'): any;
+/**
+ * Decorator that makes methods atomic - batches all effects triggered within the method
+ */
+export declare const atomic: import("../decorator").LegacyPropertyDecorator<any> & import("../decorator").ModernMethodDecorator<any> & (<Args extends any[], Return>(original: (...args: Args) => Return) => (...args: Args) => Return);
+/**
+ * @param fn - The effect function to run - provides the cleaner
+ * @returns The cleanup function
+ */
+/**
+ * Creates a reactive effect that automatically re-runs when dependencies change
+ * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
+ * @param options - Options for effect execution
+ * @returns A cleanup function to stop the effect
+ */
+export declare function effect(fn: (access: DependencyAccess) => ScopedCallback | undefined | void | Promise<any>, effectOptions?: EffectOptions): ScopedCallback & {
+    [stopped]: boolean;
+    [cleanupSymbol]: () => void;
+};
+/**
+ * Executes a function without tracking dependencies but maintains parent cleanup relationship
+ * Effects created inside will still be cleaned up when the parent effect is destroyed
+ * @param fn - The function to execute
+ */
+export declare function untracked<T>(fn: () => T): T;
+/**
+ * Executes a function from a virgin/root context - no parent effect, no tracking
+ * Creates completely independent effects that won't be cleaned up by any parent
+ * @param fn - The function to execute
+ */
+export declare function root<T>(fn: () => T): T;
+export { effectTrackers };
+/**
+ * Creates a bidirectional binding between a reactive value and a non-reactive external value
+ * Prevents infinite loops by automatically suppressing circular notifications
+ *
+ * @param received - Function called when the reactive value changes (external setter)
+ * @param get - Getter for the reactive value OR an object with `{ get, set }` properties
+ * @param set - Setter for the reactive value (required if `get` is a function)
+ * @returns A function to manually provide updates from the external side
+ *
+ * @example
+ * ```typescript
+ * const model = reactive({ value: '' })
+ * const input = { value: '' }
+ *
+ * // Bidirectional binding
+ * const provide = biDi(
+ *   (v) => input.value = v,  // external setter
+ *   () => model.value,        // reactive getter
+ *   (v) => model.value = v    // reactive setter
+ * )
+ *
+ * // External notification (e.g., from input event)
+ * provide('new value')  // Updates model.value, doesn't trigger circular loop
+ * ```
+ *
+ * @example Using object syntax
+ * ```typescript
+ * const provide = biDi(
+ *   (v) => setHTMLValue(v),
+ *   { get: () => reactiveObj.value, set: (v) => reactiveObj.value = v }
+ * )
+ * ```
+ */
+export declare function biDi<T>(received: (value: T) => void, value: {
+    get: () => T;
+    set: (value: T) => void;
+}): (value: T) => void;
+export declare function biDi<T>(received: (value: T) => void, get: () => T, set: (value: T) => void): (value: T) => void;
+//# sourceMappingURL=effects.d.ts.map

package/dist/reactive/effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.d.ts","sourceRoot":"","sources":["../../src/reactive/effects.ts"],"names":[],"mappings":"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"}

package/dist/reactive/index.d.ts

@@ -0,0 +1,20 @@
+export { getState, touched, touched1 } from './change';
+export type { ReactivityGraph } from './debug';
+export { buildReactivityGraph, enableDevTools, isDevtoolsEnabled, registerEffectForDebug, registerObjectForDebug, setEffectName, setObjectName, } from './debug';
+export { deepWatch } from './deep-watch';
+export { addBatchCleanup, atomic, biDi, defer, effect, getActivationLog, root, trackEffect, untracked, } from './effects';
+export { cleanedBy, cleanup, derived, unreactive, watch } from './interface';
+export { type Memoizable, memoize } from './memoize';
+export { immutables, isNonReactive, registerNativeReactivity } from './non-reactive';
+export { getActiveProjection, project } from './project';
+export { isReactive, ReactiveBase, reactive, unwrap } from './proxy';
+export { organize, organized } from './record';
+export { scan, type ScanResult, resolve } from './buffer';
+export { Register, register } from './register';
+export { getActiveEffect, effectAggregator } from './effect-context';
+export { type DependencyAccess, type Evolution, options as reactiveOptions, ReactiveError, ReactiveErrorCode, type ScopedCallback, } from './types';
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+export declare const profileInfo: any;
+//# sourceMappingURL=index.d.ts.map

package/dist/reactive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/reactive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EACN,oBAAoB,EACpB,cAAc,EACd,iBAAiB,EACjB,sBAAsB,EACtB,sBAAsB,EACtB,aAAa,EACb,aAAa,GACb,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACxC,OAAO,EACN,eAAe,EACf,MAAM,EACN,IAAI,EACJ,KAAK,EACL,MAAM,EACN,gBAAgB,EAChB,IAAI,EACJ,WAAW,EACX,SAAS,GACT,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAC5E,OAAO,EAAE,KAAK,UAAU,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AACpF,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACxD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACpE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,EAAE,IAAI,EAAE,KAAK,UAAU,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACpE,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,OAAO,IAAI,eAAe,EAC1B,aAAa,EACb,iBAAiB,EACjB,KAAK,cAAc,GACnB,MAAM,SAAS,CAAA;AAsBhB;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,GAUzB,CAAA"}

package/dist/reactive/interface.d.ts

@@ -0,0 +1,64 @@
+import { type GenericClassDecorator } from '../decorator';
+import { type DependencyAccess, type ScopedCallback } from './types';
+/**
+ * Symbol for accessing the cleanup function on cleaned objects
+ */
+export declare const cleanup: unique symbol;
+/**
+ * Options for the watch function
+ */
+export interface WatchOptions {
+    /** Whether to call the callback immediately */
+    immediate?: boolean;
+    /** Whether to watch nested properties */
+    deep?: boolean;
+}
+/**
+ * Watches a reactive value and calls a callback when it changes
+ * @param value - Function that returns the value to watch
+ * @param changed - Callback to call when the value changes
+ * @param options - Watch options
+ * @returns Cleanup function to stop watching
+ */
+export declare function watch<T>(value: (dep: DependencyAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep?: false;
+}): ScopedCallback;
+/**
+ * Watches a reactive value with deep watching enabled
+ * @param value - Function that returns the value to watch
+ * @param changed - Callback to call when the value changes
+ * @param options - Watch options with deep watching enabled
+ * @returns Cleanup function to stop watching
+ */
+export declare function watch<T extends object | any[]>(value: (dep: DependencyAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep: true;
+}): ScopedCallback;
+/**
+ * Watches a reactive object directly
+ * @param value - The reactive object to watch
+ * @param changed - Callback to call when the object changes
+ * @param options - Watch options
+ * @returns Cleanup function to stop watching
+ */
+export 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;
+/**
+ * Decorator that marks classes or properties as non-reactive
+ * Prevents objects from being made reactive
+ */
+export declare const unreactive: import("../decorator").LegacyClassDecorator<new (...args: any[]) => any> & import("../decorator").ModernClassDecorator<new (...args: any[]) => any> & typeof unreactiveApplication;
+export declare function cleanedBy<T extends object>(obj: T, cleanupFn: ScopedCallback): T & {
+    [cleanup]: ScopedCallback;
+};
+/**
+ * Creates a derived value that automatically recomputes when dependencies change
+ * @param compute - Function that computes the derived value
+ * @returns Object with value and cleanup function
+ */
+export declare function derived<T>(compute: (dep: DependencyAccess) => T): {
+    value: T;
+    [cleanup]: ScopedCallback;
+};
+export {};
+//# sourceMappingURL=interface.d.ts.map

package/dist/reactive/interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/reactive/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAOpE,OAAO,EACN,KAAK,gBAAgB,EAErB,KAAK,cAAc,EAEnB,MAAM,SAAS,CAAA;AAEhB;;GAEG;AACH,eAAO,MAAM,OAAO,eAAoB,CAAA;AAKxC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC5B,+CAA+C;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,yCAAyC;IACzC,IAAI,CAAC,EAAE,OAAO,CAAA;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACtB,KAAK,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,CAAC,EACnC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,IAAI,EACzC,OAAO,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,CAAC,EAAE,KAAK,CAAA;CAAE,GACrD,cAAc,CAAA;AACjB;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAAE,EAC7C,KAAK,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,CAAC,EACnC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,IAAI,EACzC,OAAO,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GACnD,cAAc,CAAA;AACjB;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAAE,EAC7C,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC3B,OAAO,CAAC,EAAE,YAAY,GACpB,cAAc,CAAA;AAgFjB,iBAAS,qBAAqB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,qBAAqB,CAAC,CAAC,CAAC,CAAA;AAChG,iBAAS,qBAAqB,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAA;AAkB3D;;;GAGG;AACH,eAAO,MAAM,UAAU,oLAMrB,CAAA;AAIF,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,cAAc,GAMtE,CAAC,GAAG;IAAE,CAAC,OAAO,CAAC,EAAE,cAAc,CAAA;CAAE,CACvC;AAID;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,CAAC,GAAG;IAClE,KAAK,EAAE,CAAC,CAAA;IACR,CAAC,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB,CAUA"}

package/dist/reactive/map.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Reactive wrapper around JavaScript's WeakMap class
+ * Only tracks individual key operations, no size tracking (WeakMap limitation)
+ */
+export declare abstract class ReactiveWeakMap<K extends object, V> extends WeakMap<K, V> {
+    get [Symbol.toStringTag](): string;
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+}
+/**
+ * Reactive wrapper around JavaScript's Map class
+ * Tracks size changes, individual key operations, and collection-wide operations
+ */
+export declare abstract class ReactiveMap<K, V> extends Map<K, V> {
+    get [Symbol.toStringTag](): string;
+    get size(): number;
+    clear(): void;
+    entries(): Generator<[K, V]>;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    keys(): MapIterator<K>;
+    values(): Generator<V>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    delete(key: K): boolean;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+}
+//# sourceMappingURL=map.d.ts.map

package/dist/reactive/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/reactive/map.ts"],"names":[],"mappings":"AAOA;;;GAGG;AACH,8BAAsB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAC/E,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;IAGD,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IASvB,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAK1B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAKpB,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;CAY3B;AAED;;;GAGG;AACH,8BAAsB,WAAW,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IACxD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,WAEvB;IAGD,IAAI,IAAI,IAAI,MAAM,CAGjB;IAED,KAAK,IAAI,IAAI;IAYb,OAAO,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAK5B,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAKpF,IAAI,IAAI,WAAW,CAAC,CAAC,CAAC;IAKtB,MAAM,IAAI,SAAS,CAAC,CAAC,CAAC;IAKtB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAsBxC,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAavB,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAK1B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAKpB,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;CAe3B"}

package/dist/reactive/memoize.d.ts

@@ -0,0 +1,5 @@
+export type Memoizable = object | any[] | symbol | ((...args: any[]) => any);
+declare function memoizeFunction<Result, Args extends Memoizable[]>(fn: (...args: Args) => Result): (...args: Args) => Result;
+export declare const memoize: import("../decorator").LegacyPropertyDecorator<any> & import("../decorator").ModernMethodDecorator<any> & import("../decorator").ModernGetterDecorator<any> & import("../decorator").ModernAccessorDecorator<any> & typeof memoizeFunction;
+export {};
+//# sourceMappingURL=memoize.d.ts.map

package/dist/reactive/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/reactive/memoize.ts"],"names":[],"mappings":"AAQA,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,GAAG,EAAE,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,CAAA;AAqB5E,iBAAS,eAAe,CAAC,MAAM,EAAE,IAAI,SAAS,UAAU,EAAE,EACzD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,GAC3B,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CA6E3B;AAED,eAAO,MAAM,OAAO,4OAoDlB,CAAA"}

package/dist/reactive/non-reactive-state.d.ts

@@ -0,0 +1,9 @@
+export declare const nonReactiveObjects: WeakSet<object>;
+export declare const immutables: Set<(tested: any) => boolean>;
+export declare const absent: unique symbol;
+declare function markNonReactive<T extends object[]>(...obj: T): T[0];
+export declare function nonReactiveClass<T extends (new (...args: any[]) => any)[]>(...cls: T): T[0];
+export declare function isNonReactive(obj: any): boolean;
+export declare function registerNativeReactivity(originalClass: new (...args: any[]) => any, reactiveClass: new (...args: any[]) => any): void;
+export { markNonReactive as nonReactive };
+//# sourceMappingURL=non-reactive-state.d.ts.map

package/dist/reactive/non-reactive-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-reactive-state.d.ts","sourceRoot":"","sources":["../../src/reactive/non-reactive-state.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,iBAAwB,CAAA;AACvD,eAAO,MAAM,UAAU,eAAoB,GAAG,KAAK,OAAO,CAAG,CAAA;AAC7D,eAAO,MAAM,MAAM,eAAmB,CAAA;AAEtC,iBAAS,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAa5D;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAG3F;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAM/C;AAED,wBAAgB,wBAAwB,CACvC,aAAa,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAC1C,aAAa,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,QAI1C;AAQD,OAAO,EAAE,eAAe,IAAI,WAAW,EAAE,CAAA"}

package/dist/reactive/non-reactive.d.ts

@@ -0,0 +1,11 @@
+import { absent, immutables, isNonReactive, nonReactive, nonReactiveClass, nonReactiveObjects, registerNativeReactivity } from './non-reactive-state';
+/**
+ * Converts an iterator to a generator that yields reactive values
+ */
+export declare function makeReactiveIterator<T>(iterator: Iterator<T>): Generator<T>;
+/**
+ * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
+ */
+export declare function makeReactiveEntriesIterator<K, V>(iterator: Iterator<[K, V]>): Generator<[K, V]>;
+export { absent, immutables, isNonReactive, nonReactive, nonReactiveClass, nonReactiveObjects, registerNativeReactivity, };
+//# sourceMappingURL=non-reactive.d.ts.map

package/dist/reactive/non-reactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"non-reactive.d.ts","sourceRoot":"","sources":["../../src/reactive/non-reactive.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,MAAM,EACN,UAAU,EACV,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,EACxB,MAAM,sBAAsB,CAAA;AAG7B;;GAEG;AACH,wBAAiB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAM5E;AAED;;GAEG;AACH,wBAAiB,2BAA2B,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAOhG;AAED,OAAO,EACN,MAAM,EACN,UAAU,EACV,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,wBAAwB,GACxB,CAAA"}

package/dist/reactive/project.d.ts

@@ -0,0 +1,41 @@
+import { cleanup } from './interface';
+import { Register } from './register';
+import { type ProjectionContext, type ScopedCallback } from './types';
+/**
+ * Maps projection effects (item effects) to their projection context
+ */
+export declare const effectProjectionMetadata: WeakMap<ScopedCallback, ProjectionContext>;
+/**
+ * Returns the projection context of the currently running effect, if any.
+ */
+export declare function getActiveProjection(): ProjectionContext | undefined;
+type ProjectOldValue<Target> = Target extends readonly (infer Item)[] ? Item : Target extends Map<any, infer Item> ? Item : Target extends Record<PropertyKey, infer Item> ? Item : unknown;
+export type ProjectAccess<SourceValue, Key, SourceType, Target> = {
+    readonly key: Key;
+    get(): SourceValue;
+    set(value: SourceValue): boolean;
+    readonly source: SourceType;
+    readonly old?: ProjectOldValue<Target>;
+    value: SourceValue;
+};
+export type ProjectCallback<SourceValue, Key, Target extends object, SourceType, Result> = (access: ProjectAccess<SourceValue, Key, SourceType, Target>, target: Target) => Result;
+export type ProjectResult<Target extends object> = Target & {
+    [cleanup]: ScopedCallback;
+};
+declare function projectArray<SourceValue, ResultValue>(source: readonly SourceValue[], apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>): ProjectResult<ResultValue[]>;
+declare function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(source: Register<SourceValue, Key>, apply: ProjectCallback<SourceValue, Key, Map<Key, ResultValue>, Register<SourceValue, Key>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+declare function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(source: Source, apply: ProjectCallback<Source[keyof Source], keyof Source, Record<keyof Source, ResultValue>, Source, ResultValue>): ProjectResult<Record<keyof Source, ResultValue>>;
+declare function projectMap<Key, Value, ResultValue>(source: Map<Key, Value>, apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+type ProjectOverload = {
+    <SourceValue, ResultValue>(source: readonly SourceValue[], apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>): ProjectResult<ResultValue[]>;
+    <Key extends PropertyKey, SourceValue, ResultValue>(source: Register<SourceValue, Key>, apply: ProjectCallback<SourceValue, Key, Map<Key, ResultValue>, Register<SourceValue, Key>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+    <Source extends Record<PropertyKey, any>, ResultValue>(source: Source, apply: ProjectCallback<Source[keyof Source], keyof Source, Record<keyof Source, ResultValue>, Source, ResultValue>): ProjectResult<Record<keyof Source, ResultValue>>;
+    <Key, Value, ResultValue>(source: Map<Key, Value>, apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
+    array: typeof projectArray;
+    register: typeof projectRegister;
+    record: typeof projectRecord;
+    map: typeof projectMap;
+};
+export declare const project: ProjectOverload;
+export {};
+//# sourceMappingURL=project.d.ts.map

package/dist/reactive/project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project.d.ts","sourceRoot":"","sources":["../../src/reactive/project.ts"],"names":[],"mappings":"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"}

package/dist/reactive/proxy-state.d.ts

@@ -0,0 +1,8 @@
+export declare const objectToProxy: WeakMap<object, object>;
+export declare const proxyToObject: WeakMap<object, object>;
+export declare function storeProxyRelationship(target: object, proxy: object): void;
+export declare function getExistingProxy<T extends object>(target: T): T | undefined;
+export declare function trackProxyObject(proxy: object, target: object): void;
+export declare function unwrap<T>(obj: T): T;
+export declare function isReactive(obj: any): boolean;
+//# sourceMappingURL=proxy-state.d.ts.map

package/dist/reactive/proxy-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy-state.d.ts","sourceRoot":"","sources":["../../src/reactive/proxy-state.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,yBAAgC,CAAA;AAC1D,eAAO,MAAM,aAAa,yBAAgC,CAAA;AAE1D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAGnE;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAE3E;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,QAE7D;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAMnC;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAE5C"}

package/dist/reactive/proxy.d.ts

@@ -0,0 +1,23 @@
+export declare const metaProtos: WeakMap<WeakKey, any>;
+/**
+ * Base mixin for reactive classes that provides proper constructor reactivity
+ * Solves constructor reactivity issues in complex inheritance trees
+ */
+export declare const ReactiveBase: (new (...args: any[]) => {
+    [x: string]: any;
+}) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => {
+    [x: string]: any;
+} & Base);
+declare function reactiveObject<T>(anyTarget: T): T;
+/**
+ * Main decorator for making classes reactive
+ * Automatically makes class instances reactive when created
+ */
+export declare const reactive: import("../decorator").LegacyClassDecorator<new (...args: any[]) => any> & import("../decorator").ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
+/**
+ * Gets the original, non-reactive object from a reactive proxy
+ * @param proxy - The reactive proxy
+ * @returns The original object
+ */
+export { isReactive, objectToProxy, proxyToObject, unwrap } from './proxy-state';
+//# sourceMappingURL=proxy.d.ts.map

package/dist/reactive/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/reactive/proxy.ts"],"names":[],"mappings":"AA+BA,eAAO,MAAM,UAAU,uBAAgB,CAAA;AAyJvC;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;SAWvB,CAAA;AACF,iBAAS,cAAc,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,GAAG,CAAC,CAsB1C;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,6KA4BnB,CAAA;AAEF;;;;GAIG;AACH,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA"}

package/dist/reactive/record.d.ts

@@ -0,0 +1,116 @@
+import { cleanup } from './interface';
+import { type ScopedCallback } from './types';
+/**
+ * Provides type-safe access to a source object's property within the organized callback.
+ * @template Source - The type of the source object
+ * @template Key - The type of the property key in the source object
+ */
+export type OrganizedAccess<Source extends Record<PropertyKey, any>, Key extends keyof Source> = {
+    /** The property key being accessed */
+    readonly key: Key;
+    /**
+     * Gets the current value of the property from the source object
+     * @returns The current value of the property
+     */
+    get(): Source[Key];
+    /**
+     * Updates the property value in the source object
+     * @param value - The new value to set
+     * @returns {boolean} True if the update was successful
+     */
+    set(value: Source[Key]): boolean;
+    /**
+     * The current value of the property (equivalent to using get()/set() directly)
+     */
+    value: Source[Key];
+};
+/**
+ * Callback function type for the organized function that processes each source property.
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object
+ */
+export type OrganizedCallback<Source extends Record<PropertyKey, any>, Target extends object> = <Key extends keyof Source>(
+/**
+ * Accessor object for the current source property
+ */
+access: OrganizedAccess<Source, Key>, 
+/**
+ * The target object where organized data will be stored
+ */
+target: Target) => ScopedCallback | undefined;
+/**
+ * The result type of the organized function, combining the target object with cleanup capability.
+ * @template Target - The type of the target object
+ */
+export type OrganizedResult<Target extends object> = Target & {
+    /**
+     * Cleanup function to dispose of all reactive bindings created by organized().
+     * This is automatically called when the effect that created the organized binding is disposed.
+     */
+    [cleanup]: ScopedCallback;
+};
+/**
+ * Organizes a source object's properties into a target object using a callback function.
+ * This creates a reactive mapping between source properties and a target object,
+ * automatically handling property additions, updates, and removals.
+ *
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
+ *
+ * @param {Source} source - The source object to organize
+ * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
+ * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
+ *
+ * @returns {OrganizedResult<Target>} The target object with cleanup capability
+ *
+ * @example
+ * // Organize user permissions into role-based access
+ * const user = reactive({ isAdmin: true, canEdit: false });
+ * const permissions = organized(
+ *   user,
+ *   (access, target) => {
+ *     if (access.key === 'isAdmin') {
+ *       target.hasFullAccess = access.value;
+ *     }
+ *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
+ *   }
+ * );
+ *
+ * @example
+ * // Transform object structure with cleanup
+ * const source = reactive({ firstName: 'John', lastName: 'Doe' });
+ * const formatted = organized(
+ *   source,
+ *   (access, target) => {
+ *     if (access.key === 'firstName' || access.key === 'lastName') {
+ *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
+ *     }
+ *   }
+ * );
+ *
+ * @example
+ * // Using with cleanup in a component
+ * effect(() => {
+ *   const data = fetchData();
+ *   const organizedData = organized(data, (access, target) => {
+ *     // Transform data
+ *   });
+ *
+ *   // The cleanup will be called automatically when the effect is disposed
+ *   return () => organizedData[cleanup]();
+ * });
+ */
+export declare function organized<Source extends Record<PropertyKey, any>, Target extends object = Record<PropertyKey, any>>(source: Source, apply: OrganizedCallback<Source, Target>, baseTarget?: Target): OrganizedResult<Target>;
+/**
+ * Organizes a property on a target object
+ * Shortcut for defineProperty/delete with touched signal
+ * @param target - The target object
+ * @param property - The property to organize
+ * @param access - The access object
+ * @returns The property descriptor
+ */
+export declare function organize<T>(target: object, property: PropertyKey, access: {
+    get?(): T;
+    set?(value: T): boolean;
+}): () => boolean;
+//# sourceMappingURL=record.d.ts.map

package/dist/reactive/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/reactive/record.ts"],"names":[],"mappings":"AAGA,OAAO,EAAa,OAAO,EAAE,MAAM,aAAa,CAAA;AAEhD,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,SAAS,CAAA;AAE7C;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,GAAG,SAAS,MAAM,MAAM,IAAI;IAChG,sCAAsC;IACtC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;IAEjB;;;OAGG;IACH,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAA;IAElB;;;;OAIG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAA;IAEhC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;CAClB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,CAAC,MAAM,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAAE,MAAM,SAAS,MAAM,IAAI,CAC/F,GAAG,SAAS,MAAM,MAAM;AAExB;;GAEG;AACH,MAAM,EAAE,eAAe,CAAC,MAAM,EAAE,GAAG,CAAC;AAEpC;;GAEG;AACH,MAAM,EAAE,MAAM,KACV,cAAc,GAAG,SAAS,CAAA;AAE/B;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,MAAM,SAAS,MAAM,IAAI,MAAM,GAAG;IAC7D;;;OAGG;IACH,CAAC,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,SAAS,CACxB,MAAM,SAAS,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EACvC,MAAM,SAAS,MAAM,GAAG,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,EAEhD,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,EACxC,UAAU,GAAE,MAAqB,GAC/B,eAAe,CAAC,MAAM,CAAC,CAgDzB;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE;IAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAA;CAAE,iBAU9C"}