cogsbox-state 0.5.297 → 0.5.299

package/src/CogsState.tsx

@@ -1814,25 +1814,29 @@ function createProxyHandler<T>(
                 endIndex: 10,
               });
 
-              // --- STATE AND CALLBACKS FOR HEIGHTS ---
-              // This state value is the key. We increment it to force a re-calculation.
               const [heightsVersion, setHeightsVersion] = useState(0);
-              // This callback is stable and won't cause re-renders itself.
               const forceRecalculate = useCallback(
                 () => setHeightsVersion((v) => v + 1),
                 []
               );
 
-              // --- ON MOUNT: SCHEDULE A RECALCULATION ---
-              // This solves the "initial load" problem. It ensures that after the first
-              // items render and measure themselves, we run the calculations again
-              // with the new, correct height data.
+              // --- This useEffect now cleanly subscribes to height changes ---
               useEffect(() => {
-                const timer = setTimeout(() => {
-                  forceRecalculate();
-                }, 50); // A small delay helps batch initial measurements.
-                return () => clearTimeout(timer);
-              }, [forceRecalculate]);
+                // Subscribe to shadow state changes for this specific key.
+                const unsubscribe = getGlobalStore
+                  .getState()
+                  .subscribeToShadowState(stateKey, forceRecalculate);
+
+                // On initial mount, we still need to trigger one recalculation
+                // to capture heights from the very first render.
+                const timer = setTimeout(forceRecalculate, 50);
+
+                // Cleanup function to unsubscribe when the component unmounts.
+                return () => {
+                  unsubscribe();
+                  clearTimeout(timer);
+                };
+              }, [stateKey, forceRecalculate]); // Runs only once on mount.
 
               const isAtBottomRef = useRef(stickToBottom);
               const previousTotalCountRef = useRef(0);
@@ -1844,27 +1848,21 @@ function createProxyHandler<T>(
               ) as any[];
               const totalCount = sourceArray.length;
 
-              // --- EFFICIENT HEIGHT & POSITION CALCULATION ---
               const { totalHeight, positions } = useMemo(() => {
-                // Get the shadow object for the whole array ONCE. This is fast.
                 const shadowArray =
                   getGlobalStore.getState().getShadowMetadata(stateKey, path) ||
                   [];
-
                 let height = 0;
                 const pos: number[] = [];
                 for (let i = 0; i < totalCount; i++) {
                   pos[i] = height;
-                  // Access the height from the local shadowArray. No repeated deep lookups.
                   const measuredHeight =
                     shadowArray[i]?.virtualizer?.itemHeight;
                   height += measuredHeight || itemHeight;
                 }
                 return { totalHeight: height, positions: pos };
-                // This now depends on `heightsVersion`, so it re-runs when we force it.
               }, [totalCount, stateKey, path, itemHeight, heightsVersion]);
 
-              // This logic is from your original working code.
               const virtualState = useMemo(() => {
                 const start = Math.max(0, range.startIndex);
                 const end = Math.min(totalCount, range.endIndex);
@@ -1877,9 +1875,7 @@ function createProxyHandler<T>(
                   ...meta,
                   validIndices,
                 });
-              }, [range.startIndex, range.endIndex, sourceArray, totalCount]);
-
-              // This is your original useLayoutEffect with the robust index calculation.
+              }, [range.startIndex, range.endIndex, sourceArray]);
               useLayoutEffect(() => {
                 const container = containerRef.current;
                 if (!container) return;
@@ -1891,9 +1887,9 @@ function createProxyHandler<T>(
                 const handleScroll = () => {
                   const { scrollTop, clientHeight, scrollHeight } = container;
                   isAtBottomRef.current =
-                    scrollHeight - scrollTop - clientHeight < 10;
+                    scrollHeight - scrollTop - clientHeight < 5; // Use a small tolerance
 
-                  // ROBUST: Binary search to find the start index. Prevents errors.
+                  // ... (binary search logic to setRange) ...
                   let search = (list: number[], value: number) => {
                     let low = 0;
                     let high = list.length - 1;
@@ -1907,9 +1903,7 @@ function createProxyHandler<T>(
                     }
                     return low;
                   };
-
                   let startIndex = search(positions, scrollTop);
-
                   let endIndex = startIndex;
                   while (
                     endIndex < totalCount &&
@@ -1917,10 +1911,8 @@ function createProxyHandler<T>(
                   ) {
                     endIndex++;
                   }
-
                   startIndex = Math.max(0, startIndex - overscan);
                   endIndex = Math.min(totalCount, endIndex + overscan);
-
                   setRange((prevRange) => {
                     if (
                       prevRange.startIndex !== startIndex ||
@@ -1935,27 +1927,28 @@ function createProxyHandler<T>(
                 container.addEventListener("scroll", handleScroll, {
                   passive: true,
                 });
+                handleScroll(); // Run once to set initial view
 
-                // This stickToBottom logic is from your original working code.
+                // --- THE SIMPLE FIX ---
+                // We check the flags *after* handleScroll has updated them.
                 if (stickToBottom) {
                   if (isInitialMountRef.current) {
+                    // On first load, always go to the bottom.
                     container.scrollTo({
                       top: container.scrollHeight,
                       behavior: "auto",
                     });
-                  } else if (wasAtBottom && listGrew) {
-                    requestAnimationFrame(() => {
-                      container.scrollTo({
-                        top: container.scrollHeight,
-                        behavior: "smooth",
-                      });
+                    isInitialMountRef.current = false;
+                  } else if (listGrew && wasAtBottom) {
+                    // If a new item was added AND we were already at the bottom,
+                    // scroll to the new bottom.
+                    container.scrollTo({
+                      top: container.scrollHeight,
+                      behavior: "auto",
                     });
                   }
                 }
 
-                isInitialMountRef.current = false;
-                handleScroll();
-
                 return () =>
                   container.removeEventListener("scroll", handleScroll);
               }, [totalCount, overscan, stickToBottom, positions]);
@@ -2950,7 +2943,6 @@ export function $cogsSignalStore(proxy: {
   );
   return createElement("text", {}, String(value));
 }
-
 function CogsItemWrapper({
   stateKey,
   itemComponentId,
@@ -2962,19 +2954,31 @@ function CogsItemWrapper({
   itemPath: string[];
   children: React.ReactNode;
 }) {
+  // This hook handles the re-rendering when the item's own data changes.
   const [, forceUpdate] = useState({});
+  // This hook measures the element.
   const [ref, bounds] = useMeasure();
+  // This ref prevents sending the same height update repeatedly.
+  const lastReportedHeight = useRef<number | null>(null);
 
+  // This is the primary effect for this component.
   useEffect(() => {
-    if (bounds.height > 0) {
+    // We only report a height if it's a valid number AND it's different
+    // from the last height we reported. This prevents infinite loops.
+    if (bounds.height > 0 && bounds.height !== lastReportedHeight.current) {
+      // Store the new height so we don't report it again.
+      lastReportedHeight.current = bounds.height;
+
+      // Call the store function to save the height and notify listeners.
       getGlobalStore.getState().setShadowMetadata(stateKey, itemPath, {
         virtualizer: {
           itemHeight: bounds.height,
         },
       });
     }
-  }, [bounds.height]);
+  }, [bounds.height, stateKey, itemPath]); // Reruns whenever the measured height changes.
 
+  // This effect handles subscribing the item to its own data path for updates.
   useLayoutEffect(() => {
     const fullComponentId = `${stateKey}////${itemComponentId}`;
     const stateEntry = getGlobalStore
@@ -3000,5 +3004,6 @@ function CogsItemWrapper({
     };
   }, [stateKey, itemComponentId, itemPath.join(".")]);
 
+  // The rendered output is a simple div that gets measured.
   return <div ref={ref}>{children}</div>;
 }

package/src/store.ts

@@ -98,8 +98,12 @@ type ShadowState<T> =
     : T extends object
       ? { [K in keyof T]: ShadowState<T[K]> } & ShadowMetadata
       : ShadowMetadata;
+
 export type CogsGlobalState = {
+  // --- Shadow State and Subscription System ---
   shadowStateStore: { [key: string]: any };
+  shadowStateSubscribers: Map<string, Set<() => void>>; // Stores subscribers for shadow state updates
+  subscribeToShadowState: (key: string, callback: () => void) => () => void; // Subscribes a listener, returns an unsubscribe function
   initializeShadowState: (key: string, initialState: any) => void;
   updateShadowAtPath: (key: string, path: string[], newValue: any) => void;
   insertShadowArrayElement: (
@@ -115,9 +119,8 @@ export type CogsGlobalState = {
   getShadowMetadata: (key: string, path: string[]) => any;
   setShadowMetadata: (key: string, path: string[], metadata: any) => void;
 
+  // --- Selected Item State ---
   selectedIndicesMap: Map<string, Map<string, number>>; // stateKey -> (parentPath -> selectedIndex)
-
-  // Add these new methods
   getSelectedIndex: (
     stateKey: string,
     parentPath: string
@@ -135,36 +138,16 @@ export type CogsGlobalState = {
     path: string[];
   }) => void;
   clearSelectedIndexesForState: (stateKey: string) => void;
+
+  // --- Core State and Updaters ---
   updaterState: { [key: string]: any };
   initialStateOptions: { [key: string]: OptionsType };
   cogsStateStore: { [key: string]: StateValue };
   isLoadingGlobal: { [key: string]: boolean };
-
   initialStateGlobal: { [key: string]: StateValue };
   iniitialCreatedState: { [key: string]: StateValue };
-  validationErrors: Map<string, string[]>;
-
   serverState: { [key: string]: StateValue };
-  serverSyncActions: { [key: string]: SyncActionsType<any> };
-
-  serverSyncLog: { [key: string]: SyncLogType[] };
-  serverSideOrNot: { [key: string]: boolean };
-  setServerSyncLog: (key: string, newValue: SyncLogType) => void;
-
-  setServerSideOrNot: (key: string, value: boolean) => void;
-  getServerSideOrNot: (key: string) => boolean | undefined;
-  setServerState: <StateKey extends StateKeys>(
-    key: StateKey,
-    value: StateValue
-  ) => void;
 
-  getThisLocalUpdate: (key: string) => UpdateTypeDetail[] | undefined;
-  setServerSyncActions: (key: string, value: SyncActionsType<any>) => void;
-  addValidationError: (path: string, message: string) => void;
-  getValidationErrors: (path: string) => string[];
-  updateInitialStateGlobal: (key: string, newState: StateValue) => void;
-  updateInitialCreatedState: (key: string, newState: StateValue) => void;
-  getInitialOptions: (key: string) => OptionsType | undefined;
   getUpdaterState: (key: string) => StateUpdater<StateValue>;
   setUpdaterState: (key: string, newUpdater: any) => void;
   getKeyState: <StateKey extends StateKeys>(key: StateKey) => StateValue;
@@ -178,15 +161,41 @@ export type CogsGlobalState = {
   ) => void;
   setInitialStates: (initialState: StateValue) => void;
   setCreatedState: (initialState: StateValue) => void;
+  updateInitialStateGlobal: (key: string, newState: StateValue) => void;
+  updateInitialCreatedState: (key: string, newState: StateValue) => void;
+  setIsLoadingGlobal: (key: string, value: boolean) => void;
+  setServerState: <StateKey extends StateKeys>(
+    key: StateKey,
+    value: StateValue
+  ) => void;
+  getInitialOptions: (key: string) => OptionsType | undefined;
+  setInitialStateOptions: (key: string, value: OptionsType) => void;
+
+  // --- Validation ---
+  validationErrors: Map<string, string[]>;
+  addValidationError: (path: string, message: string) => void;
+  getValidationErrors: (path: string) => string[];
+  removeValidationError: (path: string) => void;
+
+  // --- Server Sync and Logging ---
+  serverSyncActions: { [key: string]: SyncActionsType<any> };
+  serverSyncLog: { [key: string]: SyncLogType[] };
   stateLog: { [key: string]: UpdateTypeDetail[] };
+  syncInfoStore: Map<string, SyncInfo>;
+  serverSideOrNot: { [key: string]: boolean };
+  setServerSyncLog: (key: string, newValue: SyncLogType) => void;
+  setServerSideOrNot: (key: string, value: boolean) => void;
+  getServerSideOrNot: (key: string) => boolean | undefined;
+  getThisLocalUpdate: (key: string) => UpdateTypeDetail[] | undefined;
+  setServerSyncActions: (key: string, value: SyncActionsType<any>) => void;
   setStateLog: (
     key: string,
     updater: (prevUpdates: UpdateTypeDetail[]) => UpdateTypeDetail[]
   ) => void;
-  setIsLoadingGlobal: (key: string, value: boolean) => void;
+  setSyncInfo: (key: string, syncInfo: SyncInfo) => void;
+  getSyncInfo: (key: string) => SyncInfo | null;
 
-  setInitialStateOptions: (key: string, value: OptionsType) => void;
-  removeValidationError: (path: string) => void;
+  // --- Component and DOM Integration ---
   signalDomElements: Map<
     string,
     Set<{
@@ -208,8 +217,10 @@ export type CogsGlobalState = {
     }
   ) => void;
   removeSignalElement: (signalId: string, instanceId: string) => void;
-  reRenderTriggerPrevValue: Record<string, any>;
+  stateComponents: Map<string, ComponentsType>;
 
+  // --- Deprecated/Legacy (Review for removal) ---
+  reRenderTriggerPrevValue: Record<string, any>;
   reactiveDeps: Record<
     string,
     {
@@ -228,11 +239,6 @@ export type CogsGlobalState = {
   ) => void;
   deleteReactiveDeps: (key: string) => void;
   subscribe: (listener: () => void) => () => void;
-
-  stateComponents: Map<string, ComponentsType>;
-  syncInfoStore: Map<string, SyncInfo>;
-  setSyncInfo: (key: string, syncInfo: SyncInfo) => void;
-  getSyncInfo: (key: string) => SyncInfo | null;
 };
 
 export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
@@ -250,30 +256,6 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
     return current;
   },
 
-  setShadowMetadata: (key: string, path: string[], metadata: any) => {
-    set((state) => {
-      const newShadow = { ...state.shadowStateStore };
-      if (!newShadow[key]) return state;
-
-      newShadow[key] = JSON.parse(JSON.stringify(newShadow[key]));
-
-      let current: any = newShadow[key];
-      for (const segment of path) {
-        if (!current[segment]) current[segment] = {};
-        current = current[segment];
-      }
-
-      // Merge the metadata into the existing structure
-      Object.keys(metadata).forEach((category) => {
-        if (!current[category]) {
-          current[category] = {};
-        }
-        Object.assign(current[category], metadata[category]);
-      });
-
-      return { shadowStateStore: newShadow };
-    });
-  },
   initializeShadowState: (key: string, initialState: any) => {
     const createShadowStructure = (obj: any): any => {
       if (Array.isArray(obj)) {
@@ -389,6 +371,63 @@ export const getGlobalStore = create<CogsGlobalState>((set, get) => ({
       return { shadowStateStore: newShadow };
     });
   },
+  shadowStateSubscribers: new Map<string, Set<() => void>>(), // key -> Set of callbacks
+
+  subscribeToShadowState: (key: string, callback: () => void) => {
+    set((state) => {
+      const newSubs = new Map(state.shadowStateSubscribers);
+      const subsForKey = newSubs.get(key) || new Set();
+      subsForKey.add(callback);
+      newSubs.set(key, subsForKey);
+      return { shadowStateSubscribers: newSubs };
+    });
+    // Return an unsubscribe function
+    return () => {
+      set((state) => {
+        const newSubs = new Map(state.shadowStateSubscribers);
+        const subsForKey = newSubs.get(key);
+        if (subsForKey) {
+          subsForKey.delete(callback);
+        }
+        return { shadowStateSubscribers: newSubs };
+      });
+    };
+  },
+
+  setShadowMetadata: (key: string, path: string[], metadata: any) => {
+    let hasChanged = false;
+    set((state) => {
+      const newShadow = { ...state.shadowStateStore };
+      if (!newShadow[key]) return state;
+
+      newShadow[key] = JSON.parse(JSON.stringify(newShadow[key]));
+
+      let current: any = newShadow[key];
+      for (const segment of path) {
+        if (!current[segment]) current[segment] = {};
+        current = current[segment];
+      }
+
+      const oldHeight = current.virtualizer?.itemHeight;
+      const newHeight = metadata.virtualizer?.itemHeight;
+
+      if (newHeight && oldHeight !== newHeight) {
+        hasChanged = true;
+        if (!current.virtualizer) current.virtualizer = {};
+        current.virtualizer.itemHeight = newHeight;
+      }
+
+      return { shadowStateStore: newShadow };
+    });
+
+    // If a height value was actually changed, notify the specific subscribers.
+    if (hasChanged) {
+      const subscribers = get().shadowStateSubscribers.get(key);
+      if (subscribers) {
+        subscribers.forEach((callback) => callback());
+      }
+    }
+  },
   selectedIndicesMap: new Map<string, Map<string, number>>(),
 
   // Add the new methods