cogsbox-state 0.5.362 → 0.5.365

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cogsbox-state",
-  "version": "0.5.362",
+  "version": "0.5.365",
   "description": "React state management library with form controls and server sync",
   "type": "module",
   "main": "./dist/index.js",

package/src/CogsState.tsx

@@ -1809,14 +1809,21 @@ function createProxyHandler<T>(
                 dependencies = [],
               } = options;
 
+              type Status =
+                | "WAITING_FOR_ARRAY"
+                | "GETTING_ARRAY_HEIGHTS"
+                | "MOVING_TO_BOTTOM"
+                | "LOCKED_AT_BOTTOM"
+                | "IDLE_NOT_AT_BOTTOM";
+
               const containerRef = useRef<HTMLDivElement | null>(null);
               const [range, setRange] = useState({
                 startIndex: 0,
                 endIndex: 10,
               });
-              const isLockedToBottomRef = useRef(stickToBottom);
-              const isAutoScrolling = useRef(false);
+              const [status, setStatus] = useState<Status>("WAITING_FOR_ARRAY");
               const prevTotalCountRef = useRef(0);
+              const prevDepsRef = useRef(dependencies);
 
               const [shadowUpdateTrigger, setShadowUpdateTrigger] = useState(0);
 
@@ -1870,90 +1877,136 @@ function createProxyHandler<T>(
                 });
               }, [range.startIndex, range.endIndex, sourceArray, totalCount]);
 
-              // --- PHASE 1: Detect auto-scroll need and SET THE RANGE ---
+              // --- STATE MACHINE CONTROLLER ---
+              // This effect decides which state to transition to based on external changes.
               useLayoutEffect(() => {
+                const depsChanged = !isDeepEqual(
+                  dependencies,
+                  prevDepsRef.current
+                );
                 const hasNewItems = totalCount > prevTotalCountRef.current;
-                if (isLockedToBottomRef.current && hasNewItems) {
+
+                if (depsChanged) {
                   console.log(
-                    "PHASE 1: Auto-scroll needed. Setting range to render the last item."
+                    "STATE_TRANSITION: Deps changed. -> WAITING_FOR_ARRAY"
                   );
-                  setRange({
-                    startIndex: Math.max(0, totalCount - 10 - overscan),
-                    endIndex: totalCount,
-                  });
+                  setStatus("WAITING_FOR_ARRAY");
+                  return;
+                }
+
+                if (
+                  hasNewItems &&
+                  status === "LOCKED_AT_BOTTOM" &&
+                  stickToBottom
+                ) {
+                  console.log(
+                    "STATE_TRANSITION: New items arrived while locked. -> GETTING_ARRAY_HEIGHTS"
+                  );
+                  setStatus("GETTING_ARRAY_HEIGHTS");
                 }
+
                 prevTotalCountRef.current = totalCount;
-              }, [totalCount]);
+                prevDepsRef.current = dependencies;
+              }, [totalCount, ...dependencies]);
 
-              // --- PHASE 2: Wait for measurement and SCROLL ---
+              // --- STATE MACHINE ACTIONS ---
+              // This effect handles the actions for each state.
               useLayoutEffect(() => {
                 const container = containerRef.current;
-                const isRangeAtEnd =
-                  range.endIndex === totalCount && totalCount > 0;
+                if (!container) return;
+
+                let intervalId: NodeJS.Timeout | undefined;
 
                 if (
-                  !container ||
-                  !isLockedToBottomRef.current ||
-                  !isRangeAtEnd
+                  status === "WAITING_FOR_ARRAY" &&
+                  totalCount > 0 &&
+                  stickToBottom
                 ) {
-                  return;
-                }
-
-                console.log(
-                  "PHASE 2: Range is at the end. Starting the measurement loop."
-                );
-                let loopCount = 0;
-                const intervalId = setInterval(() => {
-                  loopCount++;
-                  console.log(`LOOP ${loopCount}: Checking last item...`);
+                  console.log(
+                    "ACTION: WAITING_FOR_ARRAY -> GETTING_ARRAY_HEIGHTS"
+                  );
+                  setStatus("GETTING_ARRAY_HEIGHTS");
+                } else if (status === "GETTING_ARRAY_HEIGHTS") {
+                  console.log(
+                    "ACTION: GETTING_ARRAY_HEIGHTS. Setting range and starting loop."
+                  );
+                  setRange({
+                    startIndex: Math.max(0, totalCount - 10 - overscan),
+                    endIndex: totalCount,
+                  });
 
-                  const lastItemIndex = totalCount - 1;
-                  const shadowArray =
-                    getGlobalStore
-                      .getState()
-                      .getShadowMetadata(stateKey, path) || [];
-                  const lastItemHeight =
-                    shadowArray[lastItemIndex]?.virtualizer?.itemHeight || 0;
+                  intervalId = setInterval(() => {
+                    const lastItemIndex = totalCount - 1;
+                    const shadowArray =
+                      getGlobalStore
+                        .getState()
+                        .getShadowMetadata(stateKey, path) || [];
+                    const lastItemHeight =
+                      shadowArray[lastItemIndex]?.virtualizer?.itemHeight || 0;
+
+                    if (lastItemHeight > 0) {
+                      clearInterval(intervalId);
+                      console.log(
+                        "ACTION: Measurement success. -> MOVING_TO_BOTTOM"
+                      );
+                      setStatus("MOVING_TO_BOTTOM");
+                    }
+                  }, 100);
+                } else if (status === "MOVING_TO_BOTTOM") {
+                  console.log("ACTION: MOVING_TO_BOTTOM. Executing scroll.");
+                  const scrollBehavior =
+                    prevTotalCountRef.current === 0 ? "auto" : "smooth";
+
+                  container.scrollTo({
+                    top: container.scrollHeight,
+                    behavior: scrollBehavior,
+                  });
 
-                  if (lastItemHeight > 0) {
-                    console.log(
-                      `%cSUCCESS: Last item height is ${lastItemHeight}. Scrolling now.`,
-                      "color: green; font-weight: bold;"
-                    );
-                    clearInterval(intervalId);
+                  // After scrolling, we are locked at the bottom.
+                  // Use a timeout to wait for the animation to finish.
+                  const timeoutId = setTimeout(
+                    () => {
+                      console.log(
+                        "ACTION: Scroll finished. -> LOCKED_AT_BOTTOM"
+                      );
+                      setStatus("LOCKED_AT_BOTTOM");
+                    },
+                    scrollBehavior === "smooth" ? 500 : 50
+                  );
 
-                    isAutoScrolling.current = true;
-                    container.scrollTo({
-                      top: container.scrollHeight,
-                      behavior: "smooth",
-                    });
-                    setTimeout(() => {
-                      isAutoScrolling.current = false;
-                    }, 1000);
-                  } else if (loopCount > 20) {
-                    console.error(
-                      "LOOP TIMEOUT: Last item was never measured. Stopping loop."
-                    );
-                    clearInterval(intervalId);
-                  } else {
-                    console.log("...WAITING. Height is not ready.");
-                  }
-                }, 100);
+                  return () => clearTimeout(timeoutId);
+                }
 
-                return () => clearInterval(intervalId);
-              }, [range.endIndex, totalCount, positions]);
+                return () => {
+                  if (intervalId) clearInterval(intervalId);
+                };
+              }, [status, totalCount, positions]);
 
-              // --- PHASE 3: Handle User Interaction and Resets ---
+              // --- USER INTERACTION ---
+              // This effect only handles user scrolls.
               useEffect(() => {
                 const container = containerRef.current;
                 if (!container) return;
 
-                console.log(
-                  "DEPENDENCY CHANGE: Resetting scroll lock and initial view."
-                );
-                isLockedToBottomRef.current = stickToBottom;
+                const handleUserScroll = () => {
+                  const isAtBottom =
+                    container.scrollHeight -
+                      container.scrollTop -
+                      container.clientHeight <
+                    1;
+                  // If the user scrolls up from a locked or scrolling state, move to idle.
+                  if (
+                    !isAtBottom &&
+                    (status === "LOCKED_AT_BOTTOM" ||
+                      status === "MOVING_TO_BOTTOM")
+                  ) {
+                    console.log(
+                      "USER_ACTION: Scrolled up. -> IDLE_NOT_AT_BOTTOM"
+                    );
+                    setStatus("IDLE_NOT_AT_BOTTOM");
+                  }
 
-                const updateVirtualRange = () => {
+                  // Update the rendered range based on scroll position.
                   const { scrollTop, clientHeight } = container;
                   let low = 0,
                     high = totalCount - 1;
@@ -1971,60 +2024,38 @@ function createProxyHandler<T>(
                   ) {
                     endIndex++;
                   }
-                  const newEndIndex = Math.min(totalCount, endIndex + overscan);
-
-                  // --- LOGGING ADDED HERE ---
-                  console.log(
-                    `RANGE UPDATE: Start: ${startIndex}, End: ${newEndIndex}, Total: ${totalCount}`
-                  );
-
-                  setRange({ startIndex, endIndex: newEndIndex });
-                };
-
-                const handleUserScroll = () => {
-                  if (isAutoScrolling.current) return;
-                  const isAtBottom =
-                    container.scrollHeight -
-                      container.scrollTop -
-                      container.clientHeight <
-                    1;
-                  if (!isAtBottom) {
-                    isLockedToBottomRef.current = false;
-                  }
-                  updateVirtualRange();
+                  setRange({
+                    startIndex,
+                    endIndex: Math.min(totalCount, endIndex + overscan),
+                  });
                 };
 
                 container.addEventListener("scroll", handleUserScroll, {
                   passive: true,
                 });
-                updateVirtualRange();
-
                 return () =>
                   container.removeEventListener("scroll", handleUserScroll);
-              }, [...dependencies, totalCount, positions]); // <--- THE FIX
+              }, [totalCount, positions, status]);
 
               const scrollToBottom = useCallback(
                 (behavior: ScrollBehavior = "smooth") => {
-                  if (containerRef.current) {
-                    isLockedToBottomRef.current = true;
-                    containerRef.current.scrollTo({
-                      top: containerRef.current.scrollHeight,
-                      behavior,
-                    });
-                  }
+                  console.log(
+                    "USER_ACTION: Clicked scroll to bottom button. -> MOVING_TO_BOTTOM"
+                  );
+                  setStatus("MOVING_TO_BOTTOM");
                 },
                 []
               );
 
               const scrollToIndex = useCallback(
                 (index: number, behavior: ScrollBehavior = "smooth") => {
-                  if (containerRef.current && positions[index] !== undefined) {
-                    isLockedToBottomRef.current = false;
-                    containerRef.current.scrollTo({
-                      top: positions[index],
-                      behavior,
-                    });
-                  }
+                  // if (containerRef.current && positions[index] !== undefined) {
+                  //   isLockedToBottomRef.current = false;
+                  //   containerRef.current.scrollTo({
+                  //     top: positions[index],
+                  //     behavior,
+                  //   });
+                  // }
                 },
                 [positions]
               );