hyperstack-react 0.3.15 → 0.4.1

package/dist/index.js

@@ -7385,6 +7385,198 @@ class MemoryAdapter {
     }
 }
 
+function getNestedValue$1(obj, path) {
+    let current = obj;
+    for (const segment of path) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function compareSortValues$1(a, b) {
+    if (a === b)
+        return 0;
+    if (a === undefined || a === null)
+        return -1;
+    if (b === undefined || b === null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number') {
+        return a - b;
+    }
+    if (typeof a === 'string' && typeof b === 'string') {
+        return a.localeCompare(b);
+    }
+    if (typeof a === 'boolean' && typeof b === 'boolean') {
+        return (a ? 1 : 0) - (b ? 1 : 0);
+    }
+    return String(a).localeCompare(String(b));
+}
+class SortedStorageDecorator {
+    constructor(inner) {
+        this.sortConfigs = new Map();
+        this.sortedKeysMap = new Map();
+        this.inner = inner;
+    }
+    get(viewPath, key) {
+        return this.inner.get(viewPath, key);
+    }
+    getAll(viewPath) {
+        const sortedKeys = this.sortedKeysMap.get(viewPath);
+        if (sortedKeys && sortedKeys.length > 0) {
+            return sortedKeys
+                .map(k => this.inner.get(viewPath, k))
+                .filter((v) => v !== null);
+        }
+        return this.inner.getAll(viewPath);
+    }
+    getAllSync(viewPath) {
+        const sortedKeys = this.sortedKeysMap.get(viewPath);
+        if (sortedKeys && sortedKeys.length > 0) {
+            return sortedKeys
+                .map(k => this.inner.getSync(viewPath, k))
+                .filter((v) => v !== null && v !== undefined);
+        }
+        return this.inner.getAllSync(viewPath);
+    }
+    getSync(viewPath, key) {
+        return this.inner.getSync(viewPath, key);
+    }
+    has(viewPath, key) {
+        return this.inner.has(viewPath, key);
+    }
+    keys(viewPath) {
+        const sortedKeys = this.sortedKeysMap.get(viewPath);
+        if (sortedKeys)
+            return [...sortedKeys];
+        return this.inner.keys(viewPath);
+    }
+    size(viewPath) {
+        return this.inner.size(viewPath);
+    }
+    set(viewPath, key, data) {
+        this.inner.set(viewPath, key, data);
+        const sortConfig = this.sortConfigs.get(viewPath);
+        if (sortConfig) {
+            this.updateSortedPosition(viewPath, key, data, sortConfig);
+        }
+    }
+    delete(viewPath, key) {
+        const sortedKeys = this.sortedKeysMap.get(viewPath);
+        if (sortedKeys) {
+            const idx = sortedKeys.indexOf(key);
+            if (idx !== -1) {
+                sortedKeys.splice(idx, 1);
+            }
+        }
+        this.inner.delete(viewPath, key);
+    }
+    clear(viewPath) {
+        if (viewPath) {
+            this.sortedKeysMap.delete(viewPath);
+            this.sortConfigs.delete(viewPath);
+        }
+        else {
+            this.sortedKeysMap.clear();
+            this.sortConfigs.clear();
+        }
+        this.inner.clear(viewPath);
+    }
+    evictOldest(viewPath) {
+        const sortedKeys = this.sortedKeysMap.get(viewPath);
+        if (sortedKeys && sortedKeys.length > 0) {
+            const oldest = sortedKeys.pop();
+            this.inner.delete(viewPath, oldest);
+            return oldest;
+        }
+        return this.inner.evictOldest?.(viewPath);
+    }
+    setViewConfig(viewPath, config) {
+        if (config.sort && !this.sortConfigs.has(viewPath)) {
+            this.sortConfigs.set(viewPath, config.sort);
+            this.rebuildSortedKeys(viewPath, config.sort);
+        }
+        this.inner.setViewConfig?.(viewPath, config);
+    }
+    getViewConfig(viewPath) {
+        const sortConfig = this.sortConfigs.get(viewPath);
+        if (sortConfig)
+            return { sort: sortConfig };
+        return this.inner.getViewConfig?.(viewPath);
+    }
+    onUpdate(callback) {
+        return this.inner.onUpdate(callback);
+    }
+    onRichUpdate(callback) {
+        return this.inner.onRichUpdate(callback);
+    }
+    notifyUpdate(viewPath, key, update) {
+        this.inner.notifyUpdate(viewPath, key, update);
+    }
+    notifyRichUpdate(viewPath, key, update) {
+        this.inner.notifyRichUpdate(viewPath, key, update);
+    }
+    updateSortedPosition(viewPath, key, data, sortConfig) {
+        let sortedKeys = this.sortedKeysMap.get(viewPath);
+        if (!sortedKeys) {
+            sortedKeys = [];
+            this.sortedKeysMap.set(viewPath, sortedKeys);
+        }
+        const existingIdx = sortedKeys.indexOf(key);
+        if (existingIdx !== -1) {
+            sortedKeys.splice(existingIdx, 1);
+        }
+        const insertIdx = this.binarySearchInsertPosition(viewPath, sortedKeys, sortConfig, key, data);
+        sortedKeys.splice(insertIdx, 0, key);
+    }
+    binarySearchInsertPosition(viewPath, sortedKeys, sortConfig, newKey, newValue) {
+        const newSortValue = getNestedValue$1(newValue, sortConfig.field);
+        const isDesc = sortConfig.order === 'desc';
+        let low = 0;
+        let high = sortedKeys.length;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            const midKey = sortedKeys[mid];
+            const midEntity = this.inner.get(viewPath, midKey);
+            const midValue = getNestedValue$1(midEntity, sortConfig.field);
+            let cmp = compareSortValues$1(newSortValue, midValue);
+            if (isDesc)
+                cmp = -cmp;
+            if (cmp === 0) {
+                cmp = newKey.localeCompare(midKey);
+            }
+            if (cmp < 0) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+    rebuildSortedKeys(viewPath, sortConfig) {
+        const allKeys = this.inner.keys(viewPath);
+        if (allKeys.length === 0)
+            return;
+        const isDesc = sortConfig.order === 'desc';
+        const entries = allKeys.map(k => [k, this.inner.get(viewPath, k)]);
+        entries.sort((a, b) => {
+            const aValue = getNestedValue$1(a[1], sortConfig.field);
+            const bValue = getNestedValue$1(b[1], sortConfig.field);
+            let cmp = compareSortValues$1(aValue, bValue);
+            if (isDesc)
+                cmp = -cmp;
+            if (cmp === 0) {
+                cmp = a[0].localeCompare(b[0]);
+            }
+            return cmp;
+        });
+        this.sortedKeysMap.set(viewPath, entries.map(([k]) => k));
+    }
+}
+
 class SubscriptionRegistry {
     constructor(connection) {
         this.subscriptions = new Map();
@@ -8177,9 +8369,10 @@ function createInstructionExecutor(wallet) {
 class HyperStack {
     constructor(url, options) {
         this.stack = options.stack;
-        this.storage = options.storage ?? new MemoryAdapter();
+        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
         this.processor = new FrameProcessor(this.storage, {
             maxEntriesPerView: options.maxEntriesPerView,
+            flushIntervalMs: options.flushIntervalMs,
         });
         this.connection = new ConnectionManager({
             websocketUrl: url,
@@ -8213,6 +8406,7 @@ class HyperStack {
             stack,
             storage: options?.storage,
             maxEntriesPerView: options?.maxEntriesPerView,
+            flushIntervalMs: options?.flushIntervalMs,
             autoReconnect: options?.autoReconnect,
             reconnectIntervals: options?.reconnectIntervals,
             maxReconnectAttempts: options?.maxReconnectAttempts,
@@ -8268,67 +8462,212 @@ class HyperStack {
     }
 }
 
-const HyperstackContext = React.createContext(null);
-function resolveNetworkConfig(network, websocketUrl) {
-    if (websocketUrl) {
-        return {
-            name: 'custom',
-            websocketUrl
-        };
+const DEFAULT_FLUSH_INTERVAL_MS = 16;
+
+class ZustandAdapter {
+    constructor(_config = {}) {
+        this.updateCallbacks = new Set();
+        this.richUpdateCallbacks = new Set();
+        this.accessOrder = new Map();
+        this.store = zustand.create((set) => ({
+            entities: new Map(),
+            viewConfigs: new Map(),
+            connectionState: 'disconnected',
+            lastError: undefined,
+            _set: (viewPath, key, data) => {
+                set((state) => {
+                    const newEntities = new Map(state.entities);
+                    const viewMap = new Map(newEntities.get(viewPath) ?? new Map());
+                    viewMap.set(key, data);
+                    newEntities.set(viewPath, viewMap);
+                    return { entities: newEntities };
+                });
+            },
+            _delete: (viewPath, key) => {
+                set((state) => {
+                    const newEntities = new Map(state.entities);
+                    const viewMap = newEntities.get(viewPath);
+                    if (viewMap) {
+                        const newViewMap = new Map(viewMap);
+                        newViewMap.delete(key);
+                        newEntities.set(viewPath, newViewMap);
+                    }
+                    return { entities: newEntities };
+                });
+            },
+            _clear: (viewPath) => {
+                set((state) => {
+                    if (viewPath) {
+                        const newEntities = new Map(state.entities);
+                        newEntities.delete(viewPath);
+                        return { entities: newEntities };
+                    }
+                    return { entities: new Map() };
+                });
+            },
+            _setConnectionState: (connectionState, lastError) => {
+                set({ connectionState, lastError });
+            },
+            _setViewConfig: (viewPath, config) => {
+                set((state) => {
+                    const newConfigs = new Map(state.viewConfigs);
+                    newConfigs.set(viewPath, config);
+                    return { viewConfigs: newConfigs };
+                });
+            },
+        }));
     }
-    if (typeof network === 'object') {
-        return network;
+    get(viewPath, key) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return null;
+        const value = viewMap.get(key);
+        return value !== undefined ? value : null;
     }
-    if (network === 'mainnet') {
-        return {
-            name: 'mainnet',
-            websocketUrl: 'wss://mainnet.hyperstack.xyz',
-        };
+    getAll(viewPath) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return [];
+        return Array.from(viewMap.values());
     }
-    if (network === 'devnet') {
-        return {
-            name: 'devnet',
-            websocketUrl: 'ws://localhost:8080',
-        };
+    getAllSync(viewPath) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return undefined;
+        return Array.from(viewMap.values());
     }
-    if (network === 'localnet') {
-        return {
-            name: 'localnet',
-            websocketUrl: 'ws://localhost:8080',
-        };
+    getSync(viewPath, key) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return undefined;
+        const value = viewMap.get(key);
+        return value !== undefined ? value : null;
+    }
+    has(viewPath, key) {
+        return this.store.getState().entities.get(viewPath)?.has(key) ?? false;
+    }
+    keys(viewPath) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return [];
+        return Array.from(viewMap.keys());
+    }
+    size(viewPath) {
+        return this.store.getState().entities.get(viewPath)?.size ?? 0;
+    }
+    set(viewPath, key, data) {
+        let order = this.accessOrder.get(viewPath);
+        if (!order) {
+            order = [];
+            this.accessOrder.set(viewPath, order);
+        }
+        const existingIdx = order.indexOf(key);
+        if (existingIdx !== -1) {
+            order.splice(existingIdx, 1);
+        }
+        order.push(key);
+        this.store.getState()._set(viewPath, key, data);
+    }
+    delete(viewPath, key) {
+        const order = this.accessOrder.get(viewPath);
+        if (order) {
+            const idx = order.indexOf(key);
+            if (idx !== -1) {
+                order.splice(idx, 1);
+            }
+        }
+        this.store.getState()._delete(viewPath, key);
+    }
+    clear(viewPath) {
+        if (viewPath) {
+            this.accessOrder.delete(viewPath);
+        }
+        else {
+            this.accessOrder.clear();
+        }
+        this.store.getState()._clear(viewPath);
+    }
+    evictOldest(viewPath) {
+        const order = this.accessOrder.get(viewPath);
+        if (!order || order.length === 0)
+            return undefined;
+        const oldest = order.shift();
+        if (oldest !== undefined) {
+            this.store.getState()._delete(viewPath, oldest);
+        }
+        return oldest;
+    }
+    onUpdate(callback) {
+        this.updateCallbacks.add(callback);
+        return () => this.updateCallbacks.delete(callback);
+    }
+    onRichUpdate(callback) {
+        this.richUpdateCallbacks.add(callback);
+        return () => this.richUpdateCallbacks.delete(callback);
+    }
+    notifyUpdate(viewPath, key, update) {
+        for (const callback of this.updateCallbacks) {
+            callback(viewPath, key, update);
+        }
+    }
+    notifyRichUpdate(viewPath, key, update) {
+        for (const callback of this.richUpdateCallbacks) {
+            callback(viewPath, key, update);
+        }
+    }
+    setConnectionState(state, error) {
+        this.store.getState()._setConnectionState(state, error);
+    }
+    setViewConfig(viewPath, config) {
+        const state = this.store.getState();
+        const existingConfig = state.viewConfigs.get(viewPath);
+        if (existingConfig)
+            return;
+        state._setViewConfig(viewPath, config);
+    }
+    getViewConfig(viewPath) {
+        return this.store.getState().viewConfigs.get(viewPath);
     }
-    throw new Error('Must provide either network or websocketUrl');
 }
+
+const HyperstackContext = React.createContext(null);
 function HyperstackProvider({ children, fallback = null, ...config }) {
-    const networkConfig = resolveNetworkConfig(config.network, config.websocketUrl);
     const clientsRef = React.useRef(new Map());
     const connectingRef = React.useRef(new Map());
-    const getOrCreateClient = React.useCallback(async (stack) => {
-        const existing = clientsRef.current.get(stack.name);
+    const getOrCreateClient = React.useCallback(async (stack, urlOverride) => {
+        const cacheKey = urlOverride ? `${stack.name}:${urlOverride}` : stack.name;
+        const existing = clientsRef.current.get(cacheKey);
         if (existing) {
             return existing.client;
         }
-        const connecting = connectingRef.current.get(stack.name);
+        const connecting = connectingRef.current.get(cacheKey);
         if (connecting) {
             return connecting;
         }
+        const adapter = new ZustandAdapter();
         const connectionPromise = HyperStack.connect(stack, {
-            url: networkConfig.websocketUrl,
+            url: urlOverride,
+            storage: adapter,
             autoReconnect: config.autoConnect,
             reconnectIntervals: config.reconnectIntervals,
             maxReconnectAttempts: config.maxReconnectAttempts,
             maxEntriesPerView: config.maxEntriesPerView,
+            flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
         }).then((client) => {
-            clientsRef.current.set(stack.name, {
+            client.onConnectionStateChange((state, error) => {
+                adapter.setConnectionState(state, error);
+            });
+            adapter.setConnectionState(client.connectionState);
+            clientsRef.current.set(cacheKey, {
                 client,
                 disconnect: () => client.disconnect()
             });
-            connectingRef.current.delete(stack.name);
+            connectingRef.current.delete(cacheKey);
             return client;
         });
-        connectingRef.current.set(stack.name, connectionPromise);
+        connectingRef.current.set(cacheKey, connectionPromise);
         return connectionPromise;
-    }, [networkConfig.websocketUrl, config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView]);
+    }, [config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView]);
     const getClient = React.useCallback((stack) => {
         if (!stack)
             return null;
@@ -8347,13 +8686,7 @@ function HyperstackProvider({ children, fallback = null, ...config }) {
     const value = {
         getOrCreateClient,
         getClient,
-        config: {
-            websocketUrl: networkConfig.websocketUrl,
-            autoConnect: config.autoConnect,
-            reconnectIntervals: config.reconnectIntervals,
-            maxReconnectAttempts: config.maxReconnectAttempts,
-            maxEntriesPerView: config.maxEntriesPerView,
-        }
+        config,
     };
     return (React.createElement(HyperstackContext.Provider, { value: value }, children));
 }
@@ -8701,21 +9034,22 @@ function useInstructionMutation(execute) {
     };
 }
 
-function useHyperstack(stack) {
+function useHyperstack(stack, options) {
     const { getOrCreateClient, getClient } = useHyperstackContext();
+    const urlOverride = options?.url;
     const [client, setClient] = React.useState(getClient(stack));
     const [isLoading, setIsLoading] = React.useState(!client);
     const [error, setError] = React.useState(null);
     React.useEffect(() => {
         const existingClient = getClient(stack);
-        if (existingClient) {
+        if (existingClient && !urlOverride) {
             setClient(existingClient);
             setIsLoading(false);
             return;
         }
         setIsLoading(true);
         setError(null);
-        getOrCreateClient(stack)
+        getOrCreateClient(stack, urlOverride)
             .then((newClient) => {
             setClient(newClient);
             setIsLoading(false);
@@ -8724,7 +9058,7 @@ function useHyperstack(stack) {
             setError(err instanceof Error ? err : new Error(String(err)));
             setIsLoading(false);
         });
-    }, [stack, getOrCreateClient, getClient]);
+    }, [stack, getOrCreateClient, getClient, urlOverride]);
     const views = React.useMemo(() => {
         const result = {};
         for (const [viewName, viewGroup] of Object.entries(stack.views)) {
@@ -8759,308 +9093,13 @@ function useHyperstack(stack) {
     return {
         views: views,
         instructions: instructions,
-        zustandStore: client?.store,
+        zustandStore: client?.store?.store,
         client: client,
         isLoading,
         error
     };
 }
 
-function getNestedValue(obj, path) {
-    let current = obj;
-    for (const segment of path) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (typeof current !== 'object')
-            return undefined;
-        current = current[segment];
-    }
-    return current;
-}
-function compareSortValues(a, b) {
-    if (a === b)
-        return 0;
-    if (a === undefined || a === null)
-        return -1;
-    if (b === undefined || b === null)
-        return 1;
-    if (typeof a === 'number' && typeof b === 'number') {
-        return a - b;
-    }
-    if (typeof a === 'string' && typeof b === 'string') {
-        return a.localeCompare(b);
-    }
-    if (typeof a === 'boolean' && typeof b === 'boolean') {
-        return (a ? 1 : 0) - (b ? 1 : 0);
-    }
-    return String(a).localeCompare(String(b));
-}
-function binarySearchInsertPosition(sortedKeys, entities, sortConfig, newKey, newValue) {
-    const newSortValue = getNestedValue(newValue, sortConfig.field);
-    const isDesc = sortConfig.order === 'desc';
-    let low = 0;
-    let high = sortedKeys.length;
-    while (low < high) {
-        const mid = Math.floor((low + high) / 2);
-        const midKey = sortedKeys[mid];
-        const midEntity = entities.get(midKey);
-        const midValue = getNestedValue(midEntity, sortConfig.field);
-        let cmp = compareSortValues(newSortValue, midValue);
-        if (isDesc)
-            cmp = -cmp;
-        if (cmp === 0) {
-            cmp = newKey.localeCompare(midKey);
-        }
-        if (cmp < 0) {
-            high = mid;
-        }
-        else {
-            low = mid + 1;
-        }
-    }
-    return low;
-}
-class ZustandAdapter {
-    constructor(_config = {}) {
-        this.updateCallbacks = new Set();
-        this.richUpdateCallbacks = new Set();
-        this.accessOrder = new Map();
-        this.store = zustand.create((set) => ({
-            entities: new Map(),
-            sortedKeys: new Map(),
-            viewConfigs: new Map(),
-            connectionState: 'disconnected',
-            lastError: undefined,
-            _set: (viewPath, key, data) => {
-                set((state) => {
-                    const newEntities = new Map(state.entities);
-                    const viewMap = new Map(newEntities.get(viewPath) ?? new Map());
-                    viewMap.set(key, data);
-                    newEntities.set(viewPath, viewMap);
-                    return { entities: newEntities };
-                });
-            },
-            _delete: (viewPath, key) => {
-                set((state) => {
-                    const newEntities = new Map(state.entities);
-                    const viewMap = newEntities.get(viewPath);
-                    if (viewMap) {
-                        const newViewMap = new Map(viewMap);
-                        newViewMap.delete(key);
-                        newEntities.set(viewPath, newViewMap);
-                    }
-                    return { entities: newEntities };
-                });
-            },
-            _clear: (viewPath) => {
-                set((state) => {
-                    if (viewPath) {
-                        const newEntities = new Map(state.entities);
-                        newEntities.delete(viewPath);
-                        const newSortedKeys = new Map(state.sortedKeys);
-                        newSortedKeys.delete(viewPath);
-                        return { entities: newEntities, sortedKeys: newSortedKeys };
-                    }
-                    return { entities: new Map(), sortedKeys: new Map() };
-                });
-            },
-            _setConnectionState: (connectionState, lastError) => {
-                set({ connectionState, lastError });
-            },
-            _setViewConfig: (viewPath, config) => {
-                set((state) => {
-                    const newConfigs = new Map(state.viewConfigs);
-                    newConfigs.set(viewPath, config);
-                    return { viewConfigs: newConfigs };
-                });
-            },
-            _updateSortedKeys: (viewPath, newSortedKeys) => {
-                set((state) => {
-                    const newSortedKeysMap = new Map(state.sortedKeys);
-                    newSortedKeysMap.set(viewPath, newSortedKeys);
-                    return { sortedKeys: newSortedKeysMap };
-                });
-            },
-        }));
-    }
-    get(viewPath, key) {
-        const entities = this.store.getState().entities;
-        const viewMap = entities.get(viewPath);
-        if (!viewMap)
-            return null;
-        const value = viewMap.get(key);
-        return value !== undefined ? value : null;
-    }
-    getAll(viewPath) {
-        const state = this.store.getState();
-        const viewMap = state.entities.get(viewPath);
-        if (!viewMap)
-            return [];
-        const sortedKeys = state.sortedKeys.get(viewPath);
-        if (sortedKeys && sortedKeys.length > 0) {
-            return sortedKeys.map(k => viewMap.get(k)).filter(v => v !== undefined);
-        }
-        return Array.from(viewMap.values());
-    }
-    getAllSync(viewPath) {
-        const state = this.store.getState();
-        const viewMap = state.entities.get(viewPath);
-        if (!viewMap)
-            return undefined;
-        const sortedKeys = state.sortedKeys.get(viewPath);
-        if (sortedKeys && sortedKeys.length > 0) {
-            return sortedKeys.map(k => viewMap.get(k)).filter(v => v !== undefined);
-        }
-        return Array.from(viewMap.values());
-    }
-    getSync(viewPath, key) {
-        const entities = this.store.getState().entities;
-        const viewMap = entities.get(viewPath);
-        if (!viewMap)
-            return undefined;
-        const value = viewMap.get(key);
-        return value !== undefined ? value : null;
-    }
-    has(viewPath, key) {
-        return this.store.getState().entities.get(viewPath)?.has(key) ?? false;
-    }
-    keys(viewPath) {
-        const viewMap = this.store.getState().entities.get(viewPath);
-        if (!viewMap)
-            return [];
-        return Array.from(viewMap.keys());
-    }
-    size(viewPath) {
-        return this.store.getState().entities.get(viewPath)?.size ?? 0;
-    }
-    set(viewPath, key, data) {
-        const state = this.store.getState();
-        const viewConfig = state.viewConfigs.get(viewPath);
-        if (viewConfig?.sort) {
-            const viewMap = state.entities.get(viewPath) ?? new Map();
-            const currentSortedKeys = [...(state.sortedKeys.get(viewPath) ?? [])];
-            const existingIdx = currentSortedKeys.indexOf(key);
-            if (existingIdx !== -1) {
-                currentSortedKeys.splice(existingIdx, 1);
-            }
-            const tempMap = new Map(viewMap);
-            tempMap.set(key, data);
-            const insertIdx = binarySearchInsertPosition(currentSortedKeys, tempMap, viewConfig.sort, key, data);
-            currentSortedKeys.splice(insertIdx, 0, key);
-            state._set(viewPath, key, data);
-            state._updateSortedKeys(viewPath, currentSortedKeys);
-        }
-        else {
-            let order = this.accessOrder.get(viewPath);
-            if (!order) {
-                order = [];
-                this.accessOrder.set(viewPath, order);
-            }
-            const existingIdx = order.indexOf(key);
-            if (existingIdx !== -1) {
-                order.splice(existingIdx, 1);
-            }
-            order.push(key);
-            state._set(viewPath, key, data);
-        }
-    }
-    delete(viewPath, key) {
-        const state = this.store.getState();
-        const viewConfig = state.viewConfigs.get(viewPath);
-        if (viewConfig?.sort) {
-            const currentSortedKeys = state.sortedKeys.get(viewPath);
-            if (currentSortedKeys) {
-                const newSortedKeys = currentSortedKeys.filter(k => k !== key);
-                state._updateSortedKeys(viewPath, newSortedKeys);
-            }
-        }
-        else {
-            const order = this.accessOrder.get(viewPath);
-            if (order) {
-                const idx = order.indexOf(key);
-                if (idx !== -1) {
-                    order.splice(idx, 1);
-                }
-            }
-        }
-        state._delete(viewPath, key);
-    }
-    clear(viewPath) {
-        if (viewPath) {
-            this.accessOrder.delete(viewPath);
-        }
-        else {
-            this.accessOrder.clear();
-        }
-        this.store.getState()._clear(viewPath);
-    }
-    evictOldest(viewPath) {
-        const order = this.accessOrder.get(viewPath);
-        if (!order || order.length === 0)
-            return undefined;
-        const oldest = order.shift();
-        if (oldest !== undefined) {
-            this.store.getState()._delete(viewPath, oldest);
-        }
-        return oldest;
-    }
-    onUpdate(callback) {
-        this.updateCallbacks.add(callback);
-        return () => this.updateCallbacks.delete(callback);
-    }
-    onRichUpdate(callback) {
-        this.richUpdateCallbacks.add(callback);
-        return () => this.richUpdateCallbacks.delete(callback);
-    }
-    notifyUpdate(viewPath, key, update) {
-        for (const callback of this.updateCallbacks) {
-            callback(viewPath, key, update);
-        }
-    }
-    notifyRichUpdate(viewPath, key, update) {
-        for (const callback of this.richUpdateCallbacks) {
-            callback(viewPath, key, update);
-        }
-    }
-    setConnectionState(state, error) {
-        this.store.getState()._setConnectionState(state, error);
-    }
-    setViewConfig(viewPath, config) {
-        const state = this.store.getState();
-        const existingConfig = state.viewConfigs.get(viewPath);
-        if (existingConfig?.sort)
-            return;
-        state._setViewConfig(viewPath, config);
-        if (config.sort) {
-            this.rebuildSortedKeys(viewPath, config.sort);
-        }
-    }
-    getViewConfig(viewPath) {
-        return this.store.getState().viewConfigs.get(viewPath);
-    }
-    rebuildSortedKeys(viewPath, sortConfig) {
-        const state = this.store.getState();
-        const viewMap = state.entities.get(viewPath);
-        if (!viewMap || viewMap.size === 0)
-            return;
-        const isDesc = sortConfig.order === 'desc';
-        const entries = Array.from(viewMap.entries());
-        entries.sort((a, b) => {
-            const aValue = getNestedValue(a[1], sortConfig.field);
-            const bValue = getNestedValue(b[1], sortConfig.field);
-            let cmp = compareSortValues(aValue, bValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = a[0].localeCompare(b[0]);
-            }
-            return cmp;
-        });
-        const sortedKeys = entries.map(([k]) => k);
-        state._updateSortedKeys(viewPath, sortedKeys);
-    }
-}
-
 exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;