cogsbox-state 0.5.466 → 0.5.468

package/src/store.ts

@@ -160,8 +160,6 @@ type ShadowNode = {
 };
 
 export type CogsGlobalState = {
-  // NEW shadow store
-  shadowStateStore: Map<string, ShadowNode>;
   setTransformCache: (
     key: string,
     path: string[],
@@ -289,9 +287,14 @@ export function buildShadowNode(value: any): ShadowNode {
 
   return { value };
 }
+// store.ts - Replace the shadow store methods with mutable versions
+// store.ts - Replace the shadow store methods with mutable versions
+
+// Module-level mutable store
+const shadowStateStore = new Map<string, ShadowNode>();
 
 export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
-  shadowStateStore: new Map<string, ShadowNode>(),
+  // Remove shadowStateStore from Zustand state
 
   setTransformCache: (
     key: string,
@@ -310,47 +313,39 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
   },
 
   initializeShadowState: (key: string, initialState: any) => {
-    set((state) => {
-      const newShadowStore = new Map(state.shadowStateStore);
-      const existingRoot =
-        newShadowStore.get(key) || newShadowStore.get(`[${key}`);
-      let preservedMetadata: Partial<ShadowMetadata> = {};
-
-      if (existingRoot?._meta) {
-        const {
-          components,
-          features,
-          lastServerSync,
-          stateSource,
-          baseServerState,
-        } = existingRoot._meta;
-        if (components) preservedMetadata.components = components;
-        if (features) preservedMetadata.features = features;
-        if (lastServerSync) preservedMetadata.lastServerSync = lastServerSync;
-        if (stateSource) preservedMetadata.stateSource = stateSource;
-        if (baseServerState)
-          preservedMetadata.baseServerState = baseServerState;
-      }
-
-      newShadowStore.delete(key);
-      newShadowStore.delete(`[${key}`);
-
-      const newRoot = buildShadowNode(initialState);
+    const existingRoot =
+      shadowStateStore.get(key) || shadowStateStore.get(`[${key}`);
+    let preservedMetadata: Partial<ShadowMetadata> = {};
+
+    if (existingRoot?._meta) {
+      const {
+        components,
+        features,
+        lastServerSync,
+        stateSource,
+        baseServerState,
+      } = existingRoot._meta;
+      if (components) preservedMetadata.components = components;
+      if (features) preservedMetadata.features = features;
+      if (lastServerSync) preservedMetadata.lastServerSync = lastServerSync;
+      if (stateSource) preservedMetadata.stateSource = stateSource;
+      if (baseServerState) preservedMetadata.baseServerState = baseServerState;
+    }
 
-      if (!newRoot._meta) newRoot._meta = {};
-      Object.assign(newRoot._meta, preservedMetadata);
+    shadowStateStore.delete(key);
+    shadowStateStore.delete(`[${key}`);
 
-      const storageKey = Array.isArray(initialState) ? `[${key}` : key;
-      newShadowStore.set(storageKey, newRoot);
+    const newRoot = buildShadowNode(initialState);
+    if (!newRoot._meta) newRoot._meta = {};
+    Object.assign(newRoot._meta, preservedMetadata);
 
-      return { shadowStateStore: newShadowStore };
-    });
+    const storageKey = Array.isArray(initialState) ? `[${key}` : key;
+    shadowStateStore.set(storageKey, newRoot);
   },
 
   getShadowNode: (key: string, path: string[]): ShadowNode | undefined => {
-    const store = get().shadowStateStore;
-    let current: any = store.get(key) || store.get(`[${key}`);
-
+    let current: any =
+      shadowStateStore.get(key) || shadowStateStore.get(`[${key}`);
     if (!current) return undefined;
     if (path.length === 0) return current;
 
@@ -375,31 +370,32 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     path: string[],
     newMetadata: Partial<ShadowMetadata>
   ) => {
-    set((state) => {
-      const newStore = new Map(state.shadowStateStore);
-      const rootKey = newStore.has(`[${key}`) ? `[${key}` : key;
-      let root = newStore.get(rootKey);
-
-      if (!root) {
-        root = {};
-        newStore.set(rootKey, root);
-      }
+    // Direct mutation - no cloning!
+    const rootKey = shadowStateStore.has(`[${key}`) ? `[${key}` : key;
+    let root = shadowStateStore.get(rootKey);
 
-      const clonedRoot: any = { ...root };
-      newStore.set(rootKey, clonedRoot);
+    if (!root) {
+      root = { _meta: newMetadata };
+      shadowStateStore.set(rootKey, root);
+      return;
+    }
 
-      let current = clonedRoot;
-      for (const segment of path) {
-        const nextNode = current[segment] || {};
-        current[segment] = { ...nextNode };
-        current = current[segment];
+    // Navigate to target without cloning
+    let current = root;
+    for (const segment of path) {
+      if (!current[segment]) {
+        current[segment] = {};
       }
+      current = current[segment];
+    }
 
-      current._meta = { ...(current._meta || {}), ...newMetadata };
-
-      return { shadowStateStore: newStore };
-    });
+    // Mutate metadata directly
+    if (!current._meta) {
+      current._meta = {};
+    }
+    Object.assign(current._meta, newMetadata);
   },
+
   getShadowValue: (
     key: string,
     path: string[],
@@ -420,7 +416,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       return node.value;
     }
 
-    // Array Check (This part is correct)
     const isArrayNode =
       node._meta &&
       Object.prototype.hasOwnProperty.call(node._meta, 'arrayKeys');
@@ -443,101 +438,107 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     }
     return result;
   },
+
   updateShadowAtPath: (key, path, newValue) => {
-    set((state) => {
-      const newStore = new Map(state.shadowStateStore);
-      const rootKey = newStore.has(`[${key}`) ? `[${key}` : key;
-      let root = newStore.get(rootKey);
-      if (!root) return state;
-      const clonedRoot: any = { ...root };
-      newStore.set(rootKey, clonedRoot);
-      let parentNode = clonedRoot;
-      for (let i = 0; i < path.length - 1; i++) {
-        parentNode[path[i]!] = { ...(parentNode[path[i]!] || {}) };
-        parentNode = parentNode[path[i]!];
+    // NO MORE set() wrapper - direct mutation!
+    const rootKey = shadowStateStore.has(`[${key}`) ? `[${key}` : key;
+    let root = shadowStateStore.get(rootKey);
+    if (!root) return;
+
+    // Navigate to parent without cloning
+    let parentNode = root;
+    for (let i = 0; i < path.length - 1; i++) {
+      if (!parentNode[path[i]!]) {
+        parentNode[path[i]!] = {};
       }
-      const targetNode =
-        path.length === 0 ? parentNode : parentNode[path[path.length - 1]!];
+      parentNode = parentNode[path[i]!];
+    }
 
-      if (!targetNode) {
-        parentNode[path[path.length - 1]!] = buildShadowNode(newValue);
-        return { shadowStateStore: newStore };
-      }
+    const targetNode =
+      path.length === 0 ? parentNode : parentNode[path[path.length - 1]!];
 
-      function intelligentMerge(nodeToUpdate: any, plainValue: any) {
-        if (
-          typeof plainValue !== 'object' ||
-          plainValue === null ||
-          Array.isArray(plainValue)
-        ) {
-          const oldMeta = nodeToUpdate._meta;
-          const newNode = buildShadowNode(plainValue);
-          if (oldMeta) {
-            newNode._meta = { ...oldMeta, ...(newNode._meta || {}) };
-          }
-          Object.keys(nodeToUpdate).forEach((key) => delete nodeToUpdate[key]);
-          Object.assign(nodeToUpdate, newNode);
-          return;
+    if (!targetNode) {
+      parentNode[path[path.length - 1]!] = buildShadowNode(newValue);
+      get().notifyPathSubscribers([key, ...path].join('.'), {
+        type: 'UPDATE',
+        newValue,
+      });
+      return;
+    }
+
+    function intelligentMerge(nodeToUpdate: any, plainValue: any) {
+      if (
+        typeof plainValue !== 'object' ||
+        plainValue === null ||
+        Array.isArray(plainValue)
+      ) {
+        const oldMeta = nodeToUpdate._meta;
+        // Clear existing properties
+        for (const key in nodeToUpdate) {
+          if (key !== '_meta') delete nodeToUpdate[key];
         }
+        const newNode = buildShadowNode(plainValue);
+        Object.assign(nodeToUpdate, newNode);
+        if (oldMeta) {
+          nodeToUpdate._meta = { ...oldMeta, ...(nodeToUpdate._meta || {}) };
+        }
+        return;
+      }
 
-        const plainValueKeys = new Set(Object.keys(plainValue));
+      const plainValueKeys = new Set(Object.keys(plainValue));
 
-        for (const propKey of plainValueKeys) {
-          const childValue = plainValue[propKey];
-          if (nodeToUpdate[propKey]) {
-            intelligentMerge(nodeToUpdate[propKey], childValue);
-          } else {
-            nodeToUpdate[propKey] = buildShadowNode(childValue);
-          }
+      for (const propKey of plainValueKeys) {
+        const childValue = plainValue[propKey];
+        if (nodeToUpdate[propKey]) {
+          intelligentMerge(nodeToUpdate[propKey], childValue);
+        } else {
+          nodeToUpdate[propKey] = buildShadowNode(childValue);
         }
+      }
 
-        for (const nodeKey in nodeToUpdate) {
-          if (
-            nodeKey === '_meta' ||
-            !Object.prototype.hasOwnProperty.call(nodeToUpdate, nodeKey)
-          )
-            continue;
+      for (const nodeKey in nodeToUpdate) {
+        if (
+          nodeKey === '_meta' ||
+          !Object.prototype.hasOwnProperty.call(nodeToUpdate, nodeKey)
+        )
+          continue;
 
-          if (!plainValueKeys.has(nodeKey)) {
-            delete nodeToUpdate[nodeKey];
-          }
+        if (!plainValueKeys.has(nodeKey)) {
+          delete nodeToUpdate[nodeKey];
         }
       }
+    }
 
-      intelligentMerge(targetNode, newValue);
+    intelligentMerge(targetNode, newValue);
 
-      get().notifyPathSubscribers([key, ...path].join('.'), {
-        type: 'UPDATE',
-        newValue,
-      });
-      return { shadowStateStore: newStore };
+    get().notifyPathSubscribers([key, ...path].join('.'), {
+      type: 'UPDATE',
+      newValue,
     });
   },
-  addItemsToArrayNode: (key, arrayPath, newItems, newKeys) => {
-    set((state) => {
-      const newStore = new Map(state.shadowStateStore);
-      const rootKey = newStore.has(`[${key}`) ? `[${key}` : key;
-      let root = newStore.get(rootKey);
-      if (!root) {
-        console.error('Root not found for state key:', key);
-        return state;
-      }
 
-      const clonedRoot = { ...root };
-      newStore.set(rootKey, clonedRoot);
+  addItemsToArrayNode: (key, arrayPath, newItems, newKeys) => {
+    // Direct mutation - no cloning!
+    const rootKey = shadowStateStore.has(`[${key}`) ? `[${key}` : key;
+    let root = shadowStateStore.get(rootKey);
+    if (!root) {
+      console.error('Root not found for state key:', key);
+      return;
+    }
 
-      let current = clonedRoot;
-      for (const segment of arrayPath) {
-        const nextNode = current[segment] || {};
-        current[segment] = { ...nextNode };
-        current = current[segment];
+    // Navigate without cloning
+    let current = root;
+    for (const segment of arrayPath) {
+      if (!current[segment]) {
+        current[segment] = {};
       }
+      current = current[segment];
+    }
 
-      Object.assign(current, newItems);
-      current._meta = { ...(current._meta || {}), arrayKeys: newKeys };
-
-      return { shadowStateStore: newStore };
-    });
+    // Mutate directly
+    Object.assign(current, newItems);
+    if (!current._meta) current._meta = {};
+    current._meta.arrayKeys = newKeys; // Direct assignment!
   },
 
   insertShadowArrayElement: (key, arrayPath, newItem, index) => {
@@ -552,15 +553,21 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     const newItemId = `id:${ulid()}`;
     const itemsToAdd = { [newItemId]: buildShadowNode(newItem) };
 
+    // Mutate the array directly
     const currentKeys = arrayNode._meta.arrayKeys;
-    const newKeys = [...currentKeys];
     const insertionPoint =
-      index !== undefined && index >= 0 && index <= newKeys.length
+      index !== undefined && index >= 0 && index <= currentKeys.length
         ? index
-        : newKeys.length;
-    newKeys.splice(insertionPoint, 0, newItemId);
+        : currentKeys.length;
+
+    if (insertionPoint >= currentKeys.length) {
+      currentKeys.push(newItemId); // O(1)
+    } else {
+      currentKeys.splice(insertionPoint, 0, newItemId); // O(n) only for middle
+    }
 
-    get().addItemsToArrayNode(key, arrayPath, itemsToAdd, newKeys);
+    // Pass the mutated array
+    get().addItemsToArrayNode(key, arrayPath, itemsToAdd, currentKeys);
 
     const arrayKey = [key, ...arrayPath].join('.');
     get().notifyPathSubscribers(arrayKey, {
@@ -570,6 +577,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       index: insertionPoint,
     });
   },
+
   insertManyShadowArrayElements: (key, arrayPath, newItems, index) => {
     if (!newItems || newItems.length === 0) {
       return;
@@ -592,15 +600,20 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       itemsToAdd[newItemId] = buildShadowNode(item);
     });
 
+    // Mutate directly
     const currentKeys = arrayNode._meta.arrayKeys;
-    const finalKeys = [...currentKeys];
     const insertionPoint =
-      index !== undefined && index >= 0 && index <= finalKeys.length
+      index !== undefined && index >= 0 && index <= currentKeys.length
         ? index
-        : finalKeys.length;
-    finalKeys.splice(insertionPoint, 0, ...newIds);
+        : currentKeys.length;
 
-    get().addItemsToArrayNode(key, arrayPath, itemsToAdd, finalKeys);
+    if (insertionPoint >= currentKeys.length) {
+      currentKeys.push(...newIds); // O(k) where k is items being added
+    } else {
+      currentKeys.splice(insertionPoint, 0, ...newIds); // O(n + k)
+    }
+
+    get().addItemsToArrayNode(key, arrayPath, itemsToAdd, currentKeys);
 
     const arrayKey = [key, ...arrayPath].join('.');
     get().notifyPathSubscribers(arrayKey, {
@@ -621,10 +634,27 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     const arrayNode = get().getShadowNode(key, arrayPath);
     if (!arrayNode?._meta?.arrayKeys) return;
 
-    const newKeys = arrayNode._meta.arrayKeys.filter((k) => k !== itemId);
+    // Mutate directly
+    const currentKeys = arrayNode._meta.arrayKeys;
+    const indexToRemove = currentKeys.indexOf(itemId);
+
+    if (indexToRemove === -1) return;
+
+    // O(1) for removing from end
+    if (indexToRemove === currentKeys.length - 1) {
+      currentKeys.pop();
+    }
+    // O(n) for removing from beginning or middle
+    else if (indexToRemove === 0) {
+      currentKeys.shift();
+    } else {
+      currentKeys.splice(indexToRemove, 1);
+    }
+
+    // Delete the actual item
     delete arrayNode[itemId];
 
-    get().setShadowMetadata(key, arrayPath, { arrayKeys: newKeys });
+    // No need to update metadata - already mutated!
 
     const arrayKey = [key, ...arrayPath].join('.');
     get().notifyPathSubscribers(arrayKey, {
@@ -634,6 +664,22 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     });
   },
 
+  registerComponent: (stateKey, fullComponentId, registration) => {
+    const rootMeta = get().getShadowMetadata(stateKey, []) || {};
+    const components = new Map(rootMeta.components);
+    components.set(fullComponentId, registration);
+    get().setShadowMetadata(stateKey, [], { components });
+  },
+
+  unregisterComponent: (stateKey, fullComponentId) => {
+    const rootMeta = get().getShadowMetadata(stateKey, []);
+    if (!rootMeta?.components) return;
+    const components = new Map(rootMeta.components);
+    if (components.delete(fullComponentId)) {
+      get().setShadowMetadata(stateKey, [], { components });
+    }
+  },
+
   addPathComponent: (stateKey, dependencyPath, fullComponentId) => {
     const metadata = get().getShadowMetadata(stateKey, dependencyPath) || {};
     const newPathComponents = new Set(metadata.pathComponents);
@@ -657,22 +703,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     }
   },
 
-  registerComponent: (stateKey, fullComponentId, registration) => {
-    const rootMeta = get().getShadowMetadata(stateKey, []) || {};
-    const components = new Map(rootMeta.components);
-    components.set(fullComponentId, registration);
-    get().setShadowMetadata(stateKey, [], { components });
-  },
-
-  unregisterComponent: (stateKey, fullComponentId) => {
-    const rootMeta = get().getShadowMetadata(stateKey, []);
-    if (!rootMeta?.components) return;
-    const components = new Map(rootMeta.components);
-    if (components.delete(fullComponentId)) {
-      get().setShadowMetadata(stateKey, [], { components });
-    }
-  },
-
   markAsDirty: (key, path, options = { bubble: true }) => {
     const setDirtyOnPath = (pathToMark: string[]) => {
       const node = get().getShadowNode(key, pathToMark);
@@ -696,6 +726,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     }
   },
 
+  // Keep these in Zustand as they need React reactivity
   serverStateUpdates: new Map(),
   setServerStateUpdate: (key, serverState) => {
     set((state) => ({
@@ -727,6 +758,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       }
     };
   },
+
   notifyPathSubscribers: (updatedPath, newValue) => {
     const subscribers = get().pathSubscribers;
     const subs = subscribers.get(updatedPath);
@@ -734,6 +766,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       subs.forEach((callback) => callback(newValue));
     }
   },
+
   selectedIndicesMap: new Map<string, string>(),
   getSelectedIndex: (arrayKey, validIds) => {
     const itemKey = get().selectedIndicesMap.get(arrayKey);
@@ -750,7 +783,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
 
   setSelectedIndex: (arrayKey: string, itemKey: string | undefined) => {
     set((state) => {
-      const newMap = new Map(state.selectedIndicesMap); // CREATE A NEW MAP!
+      const newMap = new Map(state.selectedIndicesMap);
 
       if (itemKey === undefined) {
         newMap.delete(arrayKey);
@@ -775,7 +808,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
 
   clearSelectedIndex: ({ arrayKey }: { arrayKey: string }): void => {
     set((state) => {
-      const newMap = new Map(state.selectedIndicesMap); // CREATE A NEW MAP!
+      const newMap = new Map(state.selectedIndicesMap);
       const actualKey = newMap.get(arrayKey);
       if (actualKey) {
         get().notifyPathSubscribers(actualKey, {
@@ -793,6 +826,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       };
     });
   },
+
   clearSelectedIndexesForState: (stateKey) => {
     set((state) => {
       const newMap = new Map(state.selectedIndicesMap);
@@ -838,6 +872,7 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       initialStateOptions: { ...prev.initialStateOptions, [key]: value },
     }));
   },
+
   updateInitialStateGlobal: (key, newState) => {
     set((prev) => ({
       initialStateGlobal: { ...prev.initialStateGlobal, [key]: newState },