scope-state 0.1.0

package/dist/src/config/index.d.ts

@@ -0,0 +1,84 @@
+import type { ProxyConfig, MonitoringConfig, PersistenceConfig, ScopeConfig } from '../types';
+export declare const defaultProxyConfig: ProxyConfig;
+export declare const defaultMonitoringConfig: MonitoringConfig;
+export declare const defaultPersistenceConfig: PersistenceConfig;
+export declare let proxyConfig: {
+    enabled: boolean;
+    maxDepth: number;
+    selectiveProxying: boolean;
+    trackPathUsage: boolean;
+    lazyProxyDeepObjects: boolean;
+    preProxyPaths: string[];
+    maxPathLength: number;
+    smartArrayTracking: boolean;
+    nonBlockingProxyCreation: boolean;
+    batchSize: number;
+    prioritizeUIObjects: boolean;
+    maxQueueSize: number;
+    memoryLimit: boolean;
+    memoryThreshold: number;
+    targetMemoryUsage: number;
+    proxyEvictionStrategy: "lru";
+    disableProxyingUnderPressure: boolean;
+    maxProxyCacheSize: number;
+    ultraSelectiveProxying: boolean;
+    proxySelectorPaths: boolean; /**
+     * Full-featured preset: All features enabled
+     */
+    forceMemoryCheck: boolean;
+    aggressiveMemoryManagement: boolean;
+    priorityPaths: string[];
+};
+export declare let monitoringConfig: {
+    enabled: boolean;
+    verboseLogging: boolean;
+    logSubscriptions: boolean;
+    logProxyCreation: boolean;
+    logStateChanges: boolean;
+    logPersistence: boolean;
+    logTimings: boolean;
+    autoLeakDetection: boolean;
+    leakDetectionInterval: number;
+    leakAlertThreshold: number;
+    leakScanMinimumRenderCycles: number;
+};
+export declare let persistenceConfig: {
+    enabled: boolean;
+    paths: string[] | undefined;
+    blacklist: string[];
+    batchDelay: number;
+};
+/**
+ * Get current configuration
+ */
+export declare function getConfig(): {
+    proxy: ProxyConfig;
+    monitoring: MonitoringConfig;
+    persistence: PersistenceConfig;
+};
+/**
+ * Reset all configuration to defaults
+ */
+export declare function resetConfig(): void;
+/**
+ * Quick presets for common use cases
+ */
+export declare const presets: {
+    /**
+     * Development preset: Enhanced debugging and monitoring
+     */
+    development: <T extends Record<string, any> = Record<string, any>>() => ScopeConfig<T>;
+    /**
+     * Production preset: Optimized for performance
+     */
+    production: <T_1 extends Record<string, any> = Record<string, any>>() => ScopeConfig<T_1>;
+    /**
+     * Memory-constrained preset: Minimal memory usage
+     */
+    minimal: <T_2 extends Record<string, any> = Record<string, any>>() => ScopeConfig<T_2>;
+    /**
+     * Full-featured preset: All features enabled
+     */
+    full: <T_3 extends Record<string, any> = Record<string, any>>() => ScopeConfig<T_3>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,WAAW,EACZ,MAAM,UAAU,CAAC;AAGlB,eAAO,MAAM,kBAAkB,EAAE,WAwBhC,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,gBAYrC,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,iBAKtC,CAAC;AAGF,eAAO,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;iCAyFpB;;OAEG;;;;CA3F6C,CAAC;AACnD,eAAO,IAAI,gBAAgB;;;;;;;;;;;;CAAiC,CAAC;AAC7D,eAAO,IAAI,iBAAiB;;;;;CAAkC,CAAC;AAK/D;;GAEG;AACH,wBAAgB,SAAS,IAAI;IAC3B,KAAK,EAAE,WAAW,CAAC;IACnB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,WAAW,EAAE,iBAAiB,CAAC;CAChC,CAMA;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAIlC;AAED;;GAEG;AACH,eAAO,MAAM,OAAO;IAClB;;OAEG;;IAeH;;OAEG;;IAgBH;;OAEG;;IAiBH;;OAEG;;CAeJ,CAAC"}

package/dist/src/core/listeners.d.ts

@@ -0,0 +1,24 @@
+import type { PathListeners, Listener, MonitoringStats } from '../types';
+export declare const pathListeners: PathListeners;
+export declare let monitoringStats: MonitoringStats;
+/**
+ * Subscribe to changes on a specific path
+ */
+export declare function subscribe(path: string, listener: Listener): () => void;
+/**
+ * Notify all listeners for a given path and its parents/children
+ */
+export declare function notifyListeners(path: string[]): void;
+/**
+ * Get total number of active listeners
+ */
+export declare function getListenerCount(): number;
+/**
+ * Get all active paths
+ */
+export declare function getActivePaths(): string[];
+/**
+ * Clear all listeners (for cleanup)
+ */
+export declare function clearAllListeners(): void;
+//# sourceMappingURL=listeners.d.ts.map

package/dist/src/core/listeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listeners.d.ts","sourceRoot":"","sources":["../../../src/core/listeners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAIzE,eAAO,MAAM,aAAa,EAAE,aAAyB,CAAC;AAGtD,eAAO,IAAI,eAAe,EAAE,eAwB3B,CAAC;AAEF;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI,CAqBtE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAoEpD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAMzC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,EAAE,CAEzC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAKxC"}

package/dist/src/core/monitoring.d.ts

@@ -0,0 +1,167 @@
+/// <reference types="node" />
+import { monitoringConfig } from '../config';
+import { getProxyCacheStats, optimizeMemoryUsage } from './proxy';
+/**
+ * Monitor API for debugging and memory leak detection
+ */
+export declare const monitorAPI: {
+    setEnabled: (enabled: boolean) => void;
+    setVerboseLogging: (enabled: boolean) => void;
+    configure: (config: Partial<typeof monitoringConfig>) => void;
+    getStats: () => {
+        proxyCount: number;
+        totalSubscriptionsCreated: number;
+        totalSubscriptionsRemoved: number;
+        activeSubscriptions: number;
+        pathSubscriptionCounts: Record<string, number>;
+        timings: {
+            lastNotifyTime: number;
+            lastPersistTime: number;
+            averageNotifyTime: number;
+            averagePersistTime: number;
+            notifyTimeTotal: number;
+            persistTimeTotal: number;
+            notifyCount: number;
+            persistCount: number;
+        };
+        leakDetection: {
+            lastCheckTime: number;
+            totalChecks: number;
+            leaksDetected: number;
+            renderCyclesSinceCheck: number;
+            isLeakDetectionRunning: boolean;
+            leakDetectionTimer: NodeJS.Timeout | null;
+        };
+    };
+    getListenerInfo: () => Record<string, number>;
+    checkForLeaks: (logReport?: boolean) => {
+        orphanedListeners: number;
+        mismatchedCounts: string[];
+        emptyPaths: string[];
+        totalListeners: number;
+        summary: string;
+    } | null;
+    startAutoLeakDetection: (interval?: number) => boolean;
+    stopAutoLeakDetection: () => boolean;
+    configureLeakDetection: (config: {
+        enabled?: boolean;
+        interval?: number;
+        alertThreshold?: number;
+        minimumRenderCycles?: number;
+    }) => void;
+    getLeakDetectionStats: () => {
+        isEnabled: boolean;
+        interval: number;
+        checksPerformed: number;
+        leaksDetected: number;
+        alertThreshold: number;
+    };
+    resetStats: () => void;
+    cleanupEmptyListeners: () => number;
+    getProxyCacheStats: typeof getProxyCacheStats;
+    getProxyUsageStats: () => {
+        accessedPaths: string[];
+        modifiedPaths: string[];
+        subscribedPaths: string[];
+        totalAccessedPaths: number;
+        totalModifiedPaths: number;
+        totalSubscribedPaths: number;
+    };
+    resetProxyUsageStats: () => void;
+    generatePathUsageReport: () => {
+        mostAccessedPaths: string[];
+        mostModifiedPaths: string[];
+        subscribedPaths: string[];
+        recommendations: string[];
+    };
+    optimizeMemoryUsage: typeof optimizeMemoryUsage;
+    getSelectorPathStats: () => {
+        totalSelectorPaths: number;
+        paths: string[];
+        mostAccessedSelectorPaths: string[];
+    };
+    clearSelectorPaths: () => number;
+    getSystemStatus: () => {
+        monitoring: {
+            enabled: boolean;
+            verboseLogging: boolean;
+            autoLeakDetection: boolean;
+        };
+        listeners: {
+            total: number;
+            pathCount: number;
+        };
+        proxies: {
+            cacheSize: number;
+            hitRatio: number;
+            totalCreated: number;
+        };
+        paths: {
+            accessed: number;
+            modified: number;
+            subscribed: number;
+            selectors: number;
+        };
+        leakDetection: {
+            isEnabled: boolean;
+            interval: number;
+            checksPerformed: number;
+            leaksDetected: number;
+            alertThreshold: number;
+        };
+        performance: {
+            averageNotifyTime: number;
+            averagePersistTime: number;
+            totalNotifications: number;
+            totalPersistOperations: number;
+        };
+    };
+    performHealthCheck: () => {
+        healthScore: number;
+        recommendations: string[];
+        systemStatus: {
+            monitoring: {
+                enabled: boolean;
+                verboseLogging: boolean;
+                autoLeakDetection: boolean;
+            };
+            listeners: {
+                total: number;
+                pathCount: number;
+            };
+            proxies: {
+                cacheSize: number;
+                hitRatio: number;
+                totalCreated: number;
+            };
+            paths: {
+                accessed: number;
+                modified: number;
+                subscribed: number;
+                selectors: number;
+            };
+            leakDetection: {
+                isEnabled: boolean;
+                interval: number;
+                checksPerformed: number;
+                leaksDetected: number;
+                alertThreshold: number;
+            };
+            performance: {
+                averageNotifyTime: number;
+                averagePersistTime: number;
+                totalNotifications: number;
+                totalPersistOperations: number;
+            };
+        };
+        leakReport: {
+            orphanedListeners: number;
+            mismatchedCounts: string[];
+            emptyPaths: string[];
+            totalListeners: number;
+            summary: string;
+        } | null;
+        cleanedListeners: number;
+    };
+};
+//# sourceMappingURL=monitoring.d.ts.map

package/dist/src/core/monitoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitoring.d.ts","sourceRoot":"","sources":["../../../src/core/monitoring.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAiC,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AA6CjG;;GAEG;AACH,eAAO,MAAM,UAAU;0BAEC,OAAO;iCAMA,OAAO;wBAMhB,QAAQ,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAgGnB;QAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoNF,CAAC"}

package/dist/src/core/proxy.d.ts

@@ -0,0 +1,50 @@
+import type { CustomMethods, CustomArrayMethods } from '../types';
+export declare const proxyPathMap: WeakMap<object, string[]>;
+export declare const pathUsageStats: {
+    accessedPaths: Set<string>;
+    modifiedPaths: Set<string>;
+    subscribedPaths: Set<string>;
+};
+export declare const selectorPaths: Set<string>;
+export declare const proxyCacheStats: {
+    cacheHits: number;
+    cacheMisses: number;
+    totalProxiesCreated: number;
+    activeCachedProxies: number;
+};
+export declare const memoryPressure: {
+    isUnderPressure: boolean;
+    lastCheckTime: number;
+    checkInterval: number;
+    highUsageCount: number;
+    check(): boolean;
+    estimateMemoryUsage(): number;
+};
+/**
+ * Set the initial store state for reset functionality
+ */
+export declare function setInitialStoreState(state: any): void;
+/**
+ * Create an advanced proxy with all the features from the original code
+ */
+export declare function createAdvancedProxy<T extends object>(target: T, path?: string[], depth?: number): T & (T extends any[] ? CustomArrayMethods<T[0]> : CustomMethods<T>);
+/**
+ * Clear proxy cache
+ */
+export declare function clearProxyCache(): void;
+/**
+ * Get proxy cache statistics
+ */
+export declare function getProxyCacheStats(): {
+    hitRatio: number;
+    estimatedCacheSize: number;
+    cacheHits: number;
+    cacheMisses: number;
+    totalProxiesCreated: number;
+    activeCachedProxies: number;
+};
+/**
+ * Optimize memory usage
+ */
+export declare function optimizeMemoryUsage(aggressive?: boolean): any;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/src/core/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../../src/core/proxy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGlE,eAAO,MAAM,YAAY,2BAAkC,CAAC;AAM5D,eAAO,MAAM,cAAc;;;;CAI1B,CAAC;AAGF,eAAO,MAAM,aAAa,aAAoB,CAAC;AAM/C,eAAO,MAAM,eAAe;;;;;CAK3B,CAAC;AAiGF,eAAO,MAAM,cAAc;;;;;;2BA4CF,MAAM;CAS9B,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,IAAI,CAErD;AAYD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EAClD,MAAM,EAAE,CAAC,EACT,IAAI,GAAE,MAAM,EAAO,EACnB,KAAK,GAAE,MAAU,GAChB,CAAC,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAmKrE;AA8UD;;GAEG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAUtC;AAED;;GAEG;AACH,wBAAgB,kBAAkB;;;;;;;EAMjC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,UAAQ,GAAG,GAAG,CA4B3D"}

package/dist/src/core/store.d.ts

@@ -0,0 +1,39 @@
+import type { ScopeConfig } from '../types';
+declare const defaultStore: {
+    user: {
+        name: string;
+        age: number;
+    };
+};
+export declare let store: {
+    user: {
+        name: string;
+        age: number;
+    };
+};
+export declare let initialStoreState: any;
+export type CurrentStoreType = typeof store;
+/**
+ * Initialize the store with custom initial state
+ * This function updates both the store and its type
+ */
+export declare function initializeStore<T extends Record<string, any>>(config?: ScopeConfig<T>): T extends Record<string, any> ? T : typeof defaultStore;
+/**
+ * Get the current store (for debugging)
+ */
+export declare function getStore(): {
+    user: {
+        name: string;
+        age: number;
+    };
+};
+/**
+ * Get the initial store state (for debugging)
+ */
+export declare function getInitialStore(): any;
+/**
+ * Reset the entire store to its initial state
+ */
+export declare function resetStore(): void;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/src/core/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/core/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C,QAAA,MAAM,YAAY;;;;;CAKjB,CAAC;AAGF,eAAO,IAAI,KAAK;;;;;CAAe,CAAC;AAGhC,eAAO,IAAI,iBAAiB,KAAoC,CAAC;AAGjE,MAAM,MAAM,gBAAgB,GAAG,OAAO,KAAK,CAAC;AAE5C;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAE,WAAW,CAAC,CAAC,CAAM,GAAG,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,OAAO,YAAY,CAiBnJ;AAED;;GAEG;AACH,wBAAgB,QAAQ;;;;;EAEvB;AAED;;GAEG;AACH,wBAAgB,eAAe,QAE9B;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAYjC"}

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

@@ -0,0 +1,36 @@
+/**
+ * Track dependencies during selector execution - tracks individual path segments
+ */
+export declare function trackDependencies<T>(selector: () => T): {
+    value: T;
+    paths: string[];
+};
+/**
+ * Check if we're currently tracking dependencies
+ */
+export declare function isCurrentlyTracking(): boolean;
+/**
+ * Temporarily skip tracking (for array method internals)
+ */
+export declare function skipTracking<T>(fn: () => T): T;
+/**
+ * Get current tracking state (for debugging)
+ */
+export declare function getTrackingState(): {
+    isTracking: boolean;
+    currentPath: string[];
+    skipDepth: number;
+};
+/**
+ * Add a path segment to tracking during proxy get operations
+ */
+export declare function trackPathAccess(path: string[]): void;
+/**
+ * Mark a path as modified during proxy set operations
+ */
+export declare function trackPathModification(path: string[]): void;
+/**
+ * Reset tracking state (for testing/debugging)
+ */
+export declare function resetTracking(): void;
+//# sourceMappingURL=tracking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracking.d.ts","sourceRoot":"","sources":["../../../src/core/tracking.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAqBrF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAE7C;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAO9C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI;IAClC,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB,CAMA;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAepD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAQ1D;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CAIpC"}

package/dist/src/hooks/useLocal.d.ts

@@ -0,0 +1,32 @@
+import type { CustomMethods, CustomArrayMethods } from '../types';
+/**
+ * Hook to create reactive local state that persists across component re-renders.
+ *
+ * This creates a reactive proxy object with custom methods ($merge, $set, $update, etc.)
+ * that can be used to update local component state. Unlike the global store,
+ * this state is isolated to the component instance.
+ *
+ * The state persists across re-renders but is reset when the component unmounts.
+ *
+ * @example
+ * function MyComponent() {
+ *   const localState = useLocal({ count: 0, name: 'John' });
+ *
+ *   return (
+ *     <div>
+ *       <p>Count: {localState.count}</p>
+ *       <button onClick={() => localState.$merge({ count: localState.count + 1 })}>
+ *         Increment
+ *       </button>
+ *       <button onClick={() => localState.$update('name', name => name.toUpperCase())}>
+ *         Uppercase Name
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ *
+ * @param initialState - The initial state object
+ * @returns A reactive proxy object with custom methods for state updates
+ */
+export declare function useLocal<T extends object>(initialState: T): T extends any[] ? T & CustomArrayMethods<T[0]> : T & CustomMethods<T>;
+//# sourceMappingURL=useLocal.d.ts.map

package/dist/src/hooks/useLocal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocal.d.ts","sourceRoot":"","sources":["../../../src/hooks/useLocal.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,YAAY,EAAE,CAAC,GACd,CAAC,SAAS,GAAG,EAAE,GACd,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC5B,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAQvB"}

package/dist/src/hooks/useScope.d.ts

@@ -0,0 +1,29 @@
+import type { CustomMethods, CustomArrayMethods } from '../types';
+/**
+ * Hook to subscribe to the global store and re-render when specific data changes.
+ *
+ * The hook tracks which store paths your selector function accesses and only
+ * re-renders the component when those specific paths change. This provides
+ * fine-grained reactivity without unnecessary renders.
+ *
+ * For objects, the returned value includes custom methods ($merge, $set, $delete, $update)
+ * that allow you to modify the data directly and trigger reactive updates.
+ *
+ * @example
+ * // Subscribe to user data
+ * const user = useScope(() => $.user);
+ *
+ * // Update user data directly (triggers re-render only for components using $.user)
+ * user.$merge({ name: 'New Name' });
+ *
+ * // Subscribe to a specific property
+ * const userName = useScope(() => $.user.name);
+ *
+ * // Subscribe to a computed value
+ * const isAdmin = useScope(() => $.user.role === 'admin');
+ *
+ * @param selector - Function that returns the data you want to subscribe to
+ * @returns The selected data, with custom methods attached if it's an object
+ */
+export declare function useScope<T>(selector: () => T): T extends object ? T & CustomMethods<T> : T extends Array<infer U> ? U[] & CustomArrayMethods<U> : T;
+//# sourceMappingURL=useScope.d.ts.map

package/dist/src/hooks/useScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScope.d.ts","sourceRoot":"","sources":["../../../src/hooks/useScope.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACxB,QAAQ,EAAE,MAAM,CAAC,GAChB,CAAC,SAAS,MAAM,GACf,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,GACpB,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GACxB,CAAC,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAC3B,CAAC,CAsDJ"}

package/dist/src/index.d.ts

@@ -0,0 +1,33 @@
+export { useScope } from './hooks/useScope';
+export { useLocal } from './hooks/useLocal';
+export { getConfig, resetConfig, presets } from './config';
+export { initializeStore, getStore, resetStore } from './core/store';
+export { monitorAPI } from './core/monitoring';
+export { persistenceAPI } from './persistence/advanced';
+export { setInitialStoreState, createAdvancedProxy, pathUsageStats, selectorPaths, clearProxyCache, getProxyCacheStats, optimizeMemoryUsage, proxyPathMap } from './core/proxy';
+export type { ScopeConfig, ProxyConfig, MonitoringConfig, PersistenceConfig, CustomMethods, CustomArrayMethods, StoreType, MonitoringStats, ProxyCacheStats, PathUsageStats } from './types';
+import type { StoreType, CustomMethods, CustomArrayMethods, ScopeConfig } from './types';
+/**
+ * Configure Scope with custom settings and return a properly typed store
+ * This is the main way to set up Scope with TypeScript support
+ */
+export declare function configure<T extends Record<string, any>>(config: ScopeConfig<T>): StoreType<T>;
+export declare function trackDependenciesAdvanced<T>(selector: () => T): {
+    value: T;
+    paths: string[];
+};
+export declare const $: StoreType<any>;
+export declare function createReactive<T extends object>(obj: T): T & (T extends any[] ? CustomArrayMethods<T[0]> : CustomMethods<T>);
+export declare const $local: typeof createReactive;
+export declare function isReactive(obj: any): boolean;
+export declare function activate<T>(obj: T): T;
+export declare function $activate<T>(obj: T): T;
+export declare function getProxy<T = any>(path: string | string[] | any): T;
+export declare function $get<T = any>(path: string | string[] | T): T;
+export declare const debugInfo: {
+    getListenerCount: () => any;
+    getPathCount: () => any;
+    getActivePaths: () => any;
+};
+export declare const rawStore: any;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAGrE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,EACb,MAAM,cAAc,CAAC;AAGtB,YAAY,EACV,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,SAAS,EACT,eAAe,EACf,eAAe,EACf,cAAc,EACf,MAAM,SAAS,CAAC;AAQjB,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAYzF;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrD,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,GACrB,SAAS,CAAC,CAAC,CAAC,CAwCd;AAGD,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAqB7F;AASD,eAAO,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG,CAAoB,CAAC;AAGlD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,GAAG,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAE5H;AAGD,eAAO,MAAM,MAAM,uBAAiB,CAAC;AAGrC,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAE5C;AAGD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAyBrC;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAEtC;AAED,wBAAgB,QAAQ,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC,CAsClE;AAED,wBAAgB,IAAI,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAK5D;AAcD,eAAO,MAAM,SAAS;;;;CAarB,CAAC;AAGF,eAAO,MAAM,QAAQ,KAAc,CAAC"}

package/dist/src/persistence/advanced.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Add a path to the persistence batch
+ */
+export declare function addToPersistenceBatch(path: string[]): void;
+/**
+ * Hydrate state from storage
+ */
+export declare function hydrateState(store?: any): Promise<boolean>;
+/**
+ * Load persistence configuration
+ */
+export declare function loadPersistenceConfig(): Promise<void>;
+/**
+ * Save persistence configuration
+ */
+export declare function savePersistenceConfig(): void;
+/**
+ * Persistence API - matches the original implementation
+ */
+export declare const persistenceAPI: {
+    setEnabled: (enabled: boolean) => void;
+    persistPaths: (paths: string[]) => void;
+    unpersistPaths: (paths: string[]) => void;
+    blacklistPaths: (paths: string[]) => void;
+    unblacklistPaths: (paths: string[]) => void;
+    getConfig: () => {
+        enabled: boolean;
+        paths: string[] | undefined;
+        blacklist: string[];
+        batchDelay: number;
+    };
+    setBatchDelay: (delay: number) => void;
+    reset: () => Promise<void>;
+    persist: () => void;
+    flushBatch: () => void;
+    rehydrate: (store?: any) => Promise<boolean>;
+    getBatchStatus: () => {
+        pendingPaths: string[];
+        isPersisting: boolean;
+        batchSize: number;
+    };
+};
+/**
+ * Initialize persistence system
+ */
+export declare function initializePersistence(): void;
+//# sourceMappingURL=advanced.d.ts.map

package/dist/src/persistence/advanced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced.d.ts","sourceRoot":"","sources":["../../../src/persistence/advanced.ts"],"names":[],"mappings":"AA8FA;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAQ1D;AAoDD;;GAEG;AACH,wBAAsB,YAAY,CAAC,KAAK,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAoEhE;AAED;;GAEG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAe3D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAW5C;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;0BAEH,OAAO;0BAMP,MAAM,EAAE;4BAWN,MAAM,EAAE;4BAeR,MAAM,EAAE;8BAaN,MAAM,EAAE;;;;;;;2BASX,MAAM;;;;wBA2CT,GAAG;;;;;;CAQxB,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAK5C"}

package/dist/src/persistence/storage.d.ts

@@ -0,0 +1,14 @@
+export declare let storage: LocalForage | null;
+/**
+ * Initialize storage for persistence
+ */
+export declare function initializeStorage(): void;
+/**
+ * Get the current storage instance
+ */
+export declare function getStorage(): LocalForage | null;
+/**
+ * Set a custom storage instance
+ */
+export declare function setStorage(customStorage: LocalForage): void;
+//# sourceMappingURL=storage.d.ts.map

package/dist/src/persistence/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../../src/persistence/storage.ts"],"names":[],"mappings":"AAGA,eAAO,IAAI,OAAO,EAAE,WAAW,GAAG,IAAW,CAAC;AAE9C;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAuBxC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,WAAW,GAAG,IAAI,CAE/C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,aAAa,EAAE,WAAW,GAAG,IAAI,CAE3D"}