cogsbox-state 0.5.461 → 0.5.463

package/src/store.ts

@@ -8,7 +8,7 @@ import type {
   UpdateTypeDetail,
 } from './CogsState.js';
 
-import type { ReactNode } from 'react';
+import { startTransition, type ReactNode } from 'react';
 
 type StateUpdater<StateValue> =
   | StateValue
@@ -109,7 +109,6 @@ export type ShadowMetadata = {
   lastUpdated?: number;
   value?: any;
   classSignals?: Array<{
-    // <-- ADD THIS BLOCK
     id: string;
     effect: string;
     lastClasses: string;
@@ -174,9 +173,14 @@ export type CogsEvent =
   | { type: 'INSERT'; path: string; itemKey: string; index: number }
   | { type: 'REMOVE'; path: string; itemKey: string }
   | { type: 'UPDATE'; path: string; newValue: any }
-  | { type: 'ITEMHEIGHT'; itemKey: string; height: number } // For full re-initializations (e.g., when a component is removed)
-  | { type: 'RELOAD'; path: string }; // For full re-initializations
+  | { type: 'ITEMHEIGHT'; itemKey: string; height: number }
+  | { type: 'RELOAD'; path: string };
 export type CogsGlobalState = {
+  updateQueue: Set<() => void>;
+  isFlushScheduled: boolean;
+
+  flushUpdates: () => void;
+
   // --- Shadow State and Subscription System ---
   registerComponent: (
     stateKey: string,
@@ -190,6 +194,7 @@ export type CogsGlobalState = {
     fullComponentId: string
   ) => void;
   shadowStateStore: Map<string, ShadowMetadata>;
+
   markAsDirty: (
     key: string,
     path: string[],
@@ -250,10 +255,6 @@ export type CogsGlobalState = {
   getInitialOptions: (key: string) => OptionsType | undefined;
   setInitialStateOptions: (key: string, value: OptionsType) => void;
 
-  // --- Validation ---
-
-  // --- Server Sync and Logging ---
-
   serverStateUpdates: Map<
     string,
     {
@@ -265,42 +266,44 @@ export type CogsGlobalState = {
 
   setServerStateUpdate: (key: string, serverState: any) => void;
 
-  stateLog: { [key: string]: UpdateTypeDetail[] };
+  stateLog: Map<string, Map<string, UpdateTypeDetail>>;
   syncInfoStore: Map<string, SyncInfo>;
+  addStateLog: (key: string, update: UpdateTypeDetail) => void;
 
-  setStateLog: (
-    key: string,
-    updater: (prevUpdates: UpdateTypeDetail[]) => UpdateTypeDetail[]
-  ) => void;
   setSyncInfo: (key: string, syncInfo: SyncInfo) => void;
   getSyncInfo: (key: string) => SyncInfo | null;
 };
 const isSimpleObject = (value: any): boolean => {
+  // Most common cases first
   if (value === null || typeof value !== 'object') return false;
 
-  // Handle special cases that should be treated as primitives
-  if (
-    value instanceof Uint8Array ||
-    value instanceof Int8Array ||
-    value instanceof Uint16Array ||
-    value instanceof Int16Array ||
-    value instanceof Uint32Array ||
-    value instanceof Int32Array ||
-    value instanceof Float32Array ||
-    value instanceof Float64Array ||
-    value instanceof ArrayBuffer ||
-    value instanceof Date ||
-    value instanceof RegExp ||
-    value instanceof Map ||
-    value instanceof Set
-  ) {
-    return false; // Treat as primitive
-  }
-
-  // Arrays and plain objects are complex
-  return Array.isArray(value) || value.constructor === Object;
+  // Arrays are simple objects
+  if (Array.isArray(value)) return true;
+
+  // Plain objects second most common
+  if (value.constructor === Object) return true;
+
+  // Everything else is not simple
+  return false;
 };
 export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
+  updateQueue: new Set<() => void>(),
+  // A flag to ensure we only schedule the flush once per event-loop tick.
+  isFlushScheduled: false,
+
+  // This function is called by queueMicrotask to execute all queued updates.
+  flushUpdates: () => {
+    const { updateQueue } = get();
+
+    if (updateQueue.size > 0) {
+      startTransition(() => {
+        updateQueue.forEach((updateFn) => updateFn());
+      });
+    }
+
+    // Clear the queue and reset the flag for the next event loop tick.
+    set({ updateQueue: new Set(), isFlushScheduled: false });
+  },
   addPathComponent: (stateKey, dependencyPath, fullComponentId) => {
     set((state) => {
       const newShadowStore = new Map(state.shadowStateStore);
@@ -340,20 +343,11 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
   },
   registerComponent: (stateKey, fullComponentId, registration) => {
     set((state) => {
-      // Create a new Map to ensure Zustand detects the change
       const newShadowStore = new Map(state.shadowStateStore);
-
-      // Get the metadata for the ROOT of the state (where the components map lives)
       const rootMeta = newShadowStore.get(stateKey) || {};
-
-      // Also clone the components map to avoid direct mutation
       const components = new Map(rootMeta.components);
       components.set(fullComponentId, registration);
-
-      // Update the root metadata with the new components map
       newShadowStore.set(stateKey, { ...rootMeta, components });
-
-      // Return the updated state
       return { shadowStateStore: newShadowStore };
     });
   },
@@ -362,8 +356,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     set((state) => {
       const newShadowStore = new Map(state.shadowStateStore);
       const rootMeta = newShadowStore.get(stateKey);
-
-      // If there's no metadata or no components map, do nothing
       if (!rootMeta?.components) {
         return state; // Return original state, no change needed
       }
@@ -381,40 +373,45 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     });
   },
   markAsDirty: (key: string, path: string[], options = { bubble: true }) => {
-    const newShadowStore = new Map(get().shadowStateStore);
-    let changed = false;
+    const { shadowStateStore } = get();
+    const updates = new Map<string, ShadowMetadata>();
 
     const setDirty = (currentPath: string[]) => {
       const fullKey = [key, ...currentPath].join('.');
-      const meta = newShadowStore.get(fullKey);
-
-      // We mark something as dirty if it isn't already.
-      // The original data source doesn't matter.
-      if (meta && meta.isDirty !== true) {
-        newShadowStore.set(fullKey, { ...meta, isDirty: true });
-        changed = true;
-      } else if (!meta) {
-        // If there's no metadata, create it and mark it as dirty.
-        // This handles newly created fields within an object.
-        newShadowStore.set(fullKey, { isDirty: true });
-        changed = true;
+      const meta = shadowStateStore.get(fullKey) || {};
+
+      // If already dirty, no need to update
+      if (meta.isDirty === true) {
+        return true; // Return true to indicate parent is dirty
       }
+
+      updates.set(fullKey, { ...meta, isDirty: true });
+      return false; // Not previously dirty
     };
 
-    // 1. Mark the target path itself as dirty.
+    // Mark the target path
     setDirty(path);
 
-    // 2. If `bubble` is true, walk up the path and mark all parents as dirty.
+    // Bubble up if requested
     if (options.bubble) {
       let parentPath = [...path];
       while (parentPath.length > 0) {
         parentPath.pop();
-        setDirty(parentPath);
+        const wasDirty = setDirty(parentPath);
+        if (wasDirty) {
+          break; // Stop bubbling if parent was already dirty
+        }
       }
     }
 
-    if (changed) {
-      set({ shadowStateStore: newShadowStore });
+    // Apply all updates at once
+    if (updates.size > 0) {
+      set((state) => {
+        updates.forEach((meta, key) => {
+          state.shadowStateStore.set(key, meta);
+        });
+        return state;
+      });
     }
   },
   serverStateUpdates: new Map(),
@@ -432,6 +429,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     });
   },
   shadowStateStore: new Map(),
+  getShadowNode: (key: string) => get().shadowStateStore.get(key),
   pathSubscribers: new Map<string, Set<(newValue: any) => void>>(),
 
   subscribeToPath: (path, callback) => {
@@ -464,7 +462,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     set((state) => {
       // 1. Make a copy of the current store to modify it
       const newShadowStore = new Map(state.shadowStateStore);
-
+      console.log('initializeShadowState');
       // 2. PRESERVE the existing components map before doing anything else
       const existingRootMeta = newShadowStore.get(key);
       const preservedComponents = existingRootMeta?.components;
@@ -521,47 +519,49 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
   },
 
   getShadowValue: (fullKey: string, validArrayIds?: string[]) => {
-    const shadowMeta = get().shadowStateStore.get(fullKey);
+    const memo = new Map<string, any>();
+    const reconstruct = (keyToBuild: string, ids?: string[]): any => {
+      if (memo.has(keyToBuild)) {
+        return memo.get(keyToBuild);
+      }
 
-    // If no metadata found, return undefined
-    if (!shadowMeta) {
-      return undefined;
-    }
+      const shadowMeta = get().shadowStateStore.get(keyToBuild);
+      if (!shadowMeta) {
+        return undefined;
+      }
 
-    // For primitive values, return the value
-    if (shadowMeta.value !== undefined) {
-      return shadowMeta.value;
-    }
+      if (shadowMeta.value !== undefined) {
+        return shadowMeta.value;
+      }
 
-    // For arrays, reconstruct with possible validArrayIds
-    if (shadowMeta.arrayKeys) {
-      const arrayKeys = validArrayIds ?? shadowMeta.arrayKeys;
-      const items = arrayKeys.map((itemKey) => {
-        // RECURSIVELY call getShadowValue for each item
-        return get().getShadowValue(itemKey);
-      });
-      return items;
-    }
+      let result: any; // The value we are about to build.
 
-    // For objects with fields, reconstruct object
-    if (shadowMeta.fields) {
-      const reconstructedObject: any = {};
-      Object.entries(shadowMeta.fields).forEach(([key, fieldPath]) => {
-        // RECURSIVELY call getShadowValue for each field
-        reconstructedObject[key] = get().getShadowValue(fieldPath as string);
-      });
-      return reconstructedObject;
-    }
+      if (shadowMeta.arrayKeys) {
+        const keys = ids ?? shadowMeta.arrayKeys;
+        result = [];
+        memo.set(keyToBuild, result);
+        keys.forEach((itemKey) => {
+          result.push(reconstruct(itemKey));
+        });
+      } else if (shadowMeta.fields) {
+        result = {};
+        memo.set(keyToBuild, result);
+        Object.entries(shadowMeta.fields).forEach(([key, fieldPath]) => {
+          result[key] = reconstruct(fieldPath as string);
+        });
+      } else {
+        result = undefined;
+      }
+
+      // Return the final, fully populated result.
+      return result;
+    };
 
-    return undefined;
+    // Start the process by calling the inner function on the root key.
+    return reconstruct(fullKey, validArrayIds);
   },
-  getShadowMetadata: (
-    key: string,
-    path: string[],
-    validArrayIds?: string[]
-  ) => {
+  getShadowMetadata: (key: string, path: string[]) => {
     const fullKey = [key, ...path].join('.');
-    let data = get().shadowStateStore.get(fullKey);
 
     return get().shadowStateStore.get(fullKey);
   },
@@ -727,36 +727,63 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       itemKey: itemKey, // The exact ID of the removed item
     });
   },
+
   updateShadowAtPath: (key, path, newValue) => {
-    const newShadowStore = new Map(get().shadowStateStore);
     const fullKey = [key, ...path].join('.');
 
-    const updateValue = (currentKey: string, valueToSet: any) => {
-      const meta = newShadowStore.get(currentKey);
+    // Optimization: Only update if value actually changed
+    const existingMeta = get().shadowStateStore.get(fullKey);
+    if (existingMeta?.value === newValue && !isSimpleObject(newValue)) {
+      return; // Skip update for unchanged primitives
+    }
 
-      // If it's a simple object with fields, update recursively
-      if (isSimpleObject(valueToSet) && meta && meta.fields) {
-        for (const fieldKey in valueToSet) {
-          if (Object.prototype.hasOwnProperty.call(valueToSet, fieldKey)) {
-            const childPath = meta.fields[fieldKey];
-            const childValue = valueToSet[fieldKey];
+    // CHANGE: Don't clone the entire Map, just update in place
+    set((state) => {
+      const store = state.shadowStateStore;
 
-            if (childPath) {
-              updateValue(childPath as string, childValue);
+      if (!isSimpleObject(newValue)) {
+        const meta = store.get(fullKey) || {};
+        store.set(fullKey, { ...meta, value: newValue });
+      } else {
+        // Handle objects by iterating
+        const processObject = (currentPath: string[], objectToSet: any) => {
+          const currentFullKey = [key, ...currentPath].join('.');
+          const meta = store.get(currentFullKey);
+
+          if (meta && meta.fields) {
+            for (const fieldKey in objectToSet) {
+              if (Object.prototype.hasOwnProperty.call(objectToSet, fieldKey)) {
+                const childValue = objectToSet[fieldKey];
+                const childFullPath = meta.fields[fieldKey];
+
+                if (childFullPath) {
+                  if (isSimpleObject(childValue)) {
+                    processObject(
+                      childFullPath.split('.').slice(1),
+                      childValue
+                    );
+                  } else {
+                    const existingChildMeta = store.get(childFullPath) || {};
+                    store.set(childFullPath, {
+                      ...existingChildMeta,
+                      value: childValue,
+                    });
+                  }
+                }
+              }
             }
           }
-        }
-      } else {
-        // For primitives (including Uint8Array), just replace the value
-        // This gives you useState-like behavior
-        const existing = newShadowStore.get(currentKey) || {};
-        newShadowStore.set(currentKey, { ...existing, value: valueToSet });
+        };
+
+        processObject(path, newValue);
       }
-    };
 
-    updateValue(fullKey, newValue);
-    get().notifyPathSubscribers(fullKey, { type: 'UPDATE', newValue });
-    set({ shadowStateStore: newShadowStore });
+      // Only notify after all changes are made
+      get().notifyPathSubscribers(fullKey, { type: 'UPDATE', newValue });
+
+      // Return same reference if using Zustand's immer middleware
+      return state;
+    });
   },
   selectedIndicesMap: new Map<string, string>(),
   getSelectedIndex: (arrayKey: string, validIds?: string[]): number => {
@@ -837,25 +864,29 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
 
   stateTimeline: {},
   cogsStateStore: {},
-  stateLog: {},
+  stateLog: new Map(),
 
   initialStateGlobal: {},
 
   validationErrors: new Map(),
+  addStateLog: (key, update) => {
+    set((state) => {
+      const newLog = new Map(state.stateLog);
+      const stateLogForKey = new Map(newLog.get(key));
+      const uniquePathKey = JSON.stringify(update.path);
+
+      const existing = stateLogForKey.get(uniquePathKey);
+      if (existing) {
+        // If an update for this path already exists, just modify it. (Fast)
+        existing.newValue = update.newValue;
+        existing.timeStamp = update.timeStamp;
+      } else {
+        // Otherwise, add the new update. (Fast)
+        stateLogForKey.set(uniquePathKey, { ...update });
+      }
 
-  setStateLog: (
-    key: string,
-    updater: (prevUpdates: UpdateTypeDetail[]) => UpdateTypeDetail[]
-  ) => {
-    set((prev) => {
-      const currentUpdates = prev.stateLog[key] ?? [];
-      const newUpdates = updater(currentUpdates);
-      return {
-        stateLog: {
-          ...prev.stateLog,
-          [key]: newUpdates,
-        },
-      };
+      newLog.set(key, stateLogForKey);
+      return { stateLog: newLog };
     });
   },