mutts 1.0.7 → 1.0.9

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

@@ -0,0 +1,115 @@
+import { cleanup, type EffectCloser, 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) => EffectCloser | 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/src/reactive/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/reactive/record.ts"],"names":[],"mappings":"AAKA,OAAO,EACN,OAAO,EACP,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,MAAM,SAAS,CAAA;AAEhB;;;;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,YAAY,GAAG,SAAS,CAAA;AAE7B;;;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,CA6BzB;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"}

package/dist/src/reactive/register.d.ts

@@ -0,0 +1,125 @@
+import { ArrayReadForward, forwardArray, getAt, setAt } from '../indexable';
+type KeyFunction<T, K extends PropertyKey> = (item: T) => K;
+/**
+ * Events emitted by the Register for CRUD operations
+ */
+export interface RegisterEvents<T, K extends PropertyKey> {
+    /**
+     * Emitted when a new item is added to the register
+     */
+    add: (item: T, key: K, index: number) => void;
+    /**
+     * Emitted when an item is removed from the register
+     */
+    delete: (item: T, key: K, index: number) => void;
+    /**
+     * Emitted when an item's value is updated (same key, new value)
+     */
+    update: (oldItem: T, newItem: T, key: K, index: number) => void;
+    /**
+     * Emitted when an item's key changes (rekey operation)
+     */
+    rekey: (item: T, oldKey: K, newKey: K, index: number) => void;
+    /**
+     * Index signature for EventsBase compatibility
+     */
+    [key: string]: (...args: any[]) => void;
+}
+interface RegisterInstance<T> extends ArrayReadForward<T> {
+    [index: number]: T;
+}
+declare const RegisterClass_base: new () => ArrayReadForward<any> & {
+    [x: number]: any;
+    toArray(): any[];
+};
+declare class RegisterClass<T, K extends PropertyKey = PropertyKey> extends RegisterClass_base implements RegisterInstance<T> {
+    #private;
+    protected get [forwardArray](): readonly T[];
+    /**
+     * Register event listeners for CRUD operations
+     */
+    on(events: Partial<RegisterEvents<T, K>>): void;
+    on<EventType extends keyof RegisterEvents<T, K>>(event: EventType, cb: RegisterEvents<T, K>[EventType]): () => void;
+    /**
+     * Remove event listeners
+     */
+    off(events: Partial<RegisterEvents<T, K>>): void;
+    off<EventType extends keyof RegisterEvents<T, K>>(event: EventType, cb?: RegisterEvents<T, K>[EventType]): void;
+    /**
+     * Register a global hook that receives all events
+     */
+    hook(cb: <EventType extends keyof RegisterEvents<T, K>>(event: EventType, ...args: Parameters<RegisterEvents<T, K>[EventType]>) => void): () => void;
+    constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>);
+    private ensureKey;
+    private assertValidKey;
+    private setKeyValue;
+    private cleanupValue;
+    private disposeKeyEffects;
+    private incrementUsage;
+    private decrementUsage;
+    private normalizeIndex;
+    private assignAt;
+    private insertKeyValue;
+    private rebuildFrom;
+    get length(): number;
+    [getAt](index: number): T | undefined;
+    [setAt](index: number, value: T): void;
+    push(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    unshift(...items: T[]): number;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    clear(): void;
+    get(key: K): T | undefined;
+    set(key: K, value: T): void;
+    remove(key: K): void;
+    removeAt(index: number): T | undefined;
+    /**
+     * Keep only the items for which the predicate returns true.
+     * Items for which the predicate returns false are removed.
+     *
+     * The predicate is evaluated once per distinct key; duplicate keys
+     * will follow the same keep/remove decision.
+     */
+    keep(predicate: (value: T) => boolean): void;
+    hasKey(key: K): boolean;
+    indexOfKey(key: K): number;
+    mapKeys(): IterableIterator<K>;
+    update(...values: T[]): void;
+    upsert(insert: (value: T) => void, ...values: T[]): void;
+    entries(): IterableIterator<[number, T]>;
+    [Symbol.iterator](): IterableIterator<T>;
+    toString(): string;
+    at(index: number): T | undefined;
+    reverse(): this;
+    sort(compareFn?: ((a: T, b: T) => number) | undefined): this;
+    fill(value: T, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
+}
+export type Register<T, K extends PropertyKey = PropertyKey> = RegisterClass<T, K> & T[];
+export declare const Register: new <T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>) => Register<T, K>;
+/**
+ * Creates a reactive Register - an ordered, array-like collection with stable key-based identity.
+ *
+ * Register combines array semantics (indexable access, ordering, iteration) with Map-like
+ * key-based lookups. Items with the same key share the same value instance, making it ideal
+ * for UI lists keyed by IDs or when you need to preserve identity across reorders.
+ *
+ * @param keyFn - Function that extracts the key from each item
+ * @param initial - Optional initial items to populate the register
+ * @returns A reactive Register instance
+ *
+ * @example
+ * ```typescript
+ * const users = register(
+ *   (user: User) => user.id,
+ *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ * )
+ *
+ * users.push({ id: 3, name: 'Charlie' })
+ * const bob = users.get(2) // Get by key
+ * ```
+ */
+export declare function register<T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>): Register<T, K>;
+export {};
+//# sourceMappingURL=register.d.ts.map

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

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

package/dist/src/reactive/registry.d.ts

@@ -0,0 +1,21 @@
+import { type EffectNode, type EffectTrigger } from './types';
+export declare let effectToReactiveObjects: WeakMap<import("./types").ScopedCallback, Set<object>>;
+export declare let watchers: WeakMap<object, Map<any, Set<import("./types").ScopedCallback>>>;
+export declare let effectNodes: WeakMap<import("./types").ScopedCallback, EffectNode>;
+export declare function getEffectNode(effect: EffectTrigger): EffectNode;
+export declare function resetRegistry(): void;
+/**
+ * Marks a function with its root function for effect tracking
+ * Enforces strict unicity: A root function can only identify ONE function.
+ * @param fn - The function to mark
+ * @param root - The root function
+ * @returns The marked function
+ */
+export declare function markWithRoot<T extends Function>(fn: T, root: any): T;
+/**
+ * Gets the root function of a function for effect tracking
+ * @param fn - The function to get the root of
+ * @returns The root function
+ */
+export declare function getRoot<T extends Function | undefined>(fn: T): T;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/reactive/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,UAAU,EAAE,KAAK,aAAa,EAAgB,MAAM,SAAS,CAAA;AAG/F,eAAO,IAAI,uBAAuB,wDAA4C,CAAA;AAG9E,eAAO,IAAI,QAAQ,kEAAsD,CAAA;AAGzE,eAAO,IAAI,WAAW,uDAA2C,CAAA;AAEjE,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU,CAO/D;AAKD,wBAAgB,aAAa,SAK5B;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC,CAwBpE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,QAAQ,GAAG,SAAS,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAGhE"}

package/dist/src/reactive/set.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Reactive wrapper around JavaScript's WeakSet class
+ * Only tracks individual value operations, no size tracking (WeakSet limitation)
+ */
+export declare abstract class ReactiveWeakSet<T extends object> extends WeakSet<T> {
+    add(value: T): this;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+}
+/**
+ * Reactive wrapper around JavaScript's Set class
+ * Tracks size changes, individual value operations, and collection-wide operations
+ */
+export declare abstract class ReactiveSet<T> extends Set<T> {
+    get size(): number;
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+    entries(): Generator<[T, T]>;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    keys(): Generator<T>;
+    values(): Generator<T>;
+    [Symbol.iterator](): SetIterator<T>;
+}
+//# sourceMappingURL=set.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../../src/reactive/set.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,8BAAsB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACzE,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAWnB,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAOzB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;CAItB;AAED;;;GAGG;AACH,8BAAsB,WAAW,CAAC,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,CAAC;IAClD,IAAI,IAAI,IAAI,MAAM,CAIjB;IAED,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAanB,KAAK,IAAI,IAAI;IAUb,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAWzB,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAKtB,OAAO,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAK5B,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAKpF,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC;IAKpB,MAAM,IAAI,SAAS,CAAC,CAAC,CAAC;IAKtB,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC;CAWnC"}

package/dist/src/reactive/tracking.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Marks a property as a dependency of the current effect
+ * @param obj - The object containing the property
+ * @param prop - The property name (defaults to allProps)
+ */
+export declare function dependant(obj: any, prop?: any): void;
+//# sourceMappingURL=tracking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracking.d.ts","sourceRoot":"","sources":["../../../src/reactive/tracking.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,GAAE,GAAc,QA8BvD"}