@inertiajs/core 2.2.0 → 2.2.2

package/dist/index.js

@@ -750,6 +750,11 @@ var History = class {
       this.replaceState(this.current);
     }
   }
+  clearInitialState(key) {
+    if (this.initialState && this.initialState[key] !== void 0) {
+      delete this.initialState[key];
+    }
+  }
   hasAnyState() {
     return !!this.getAllState();
   }
@@ -879,6 +884,7 @@ var InitialVisit = class {
   static clearRememberedStateOnReload() {
     if (navigationType.isReload()) {
       history.deleteState(history.rememberedState);
+      history.clearInitialState(history.rememberedState);
     }
   }
   static handleBackForward() {
@@ -2421,8 +2427,26 @@ var useInfiniteScrollData = (options) => {
     loading: false,
     previousPage,
     nextPage,
-    lastLoadedPage
+    lastLoadedPage,
+    requestCount: 0
   };
+  const getRememberKey = () => `inertia:infinite-scroll-data:${options.getPropName()}`;
+  const rememberedState = router.restore(getRememberKey());
+  if (rememberedState && typeof rememberedState === "object") {
+    state.previousPage = rememberedState.previousPage;
+    state.nextPage = rememberedState.nextPage;
+    state.lastLoadedPage = rememberedState.lastLoadedPage;
+    state.requestCount = rememberedState.requestCount || 0;
+  }
+  const removeEventListener = router.on("success", () => {
+    const scrollProp = getScrollPropFromCurrentPage();
+    if (scrollProp.reset) {
+      state.previousPage = scrollProp.previousPage;
+      state.nextPage = scrollProp.nextPage;
+      state.lastLoadedPage = scrollProp.currentPage;
+      state.requestCount = 0;
+    }
+  });
   const getScrollPropKeyForSide = (side) => {
     return side === "next" ? "nextPage" : "previousPage";
   };
@@ -2435,8 +2459,19 @@ var useInfiniteScrollData = (options) => {
     const paginationProp = getScrollPropKeyForSide(side);
     state.lastLoadedPage = scrollProp.currentPage;
     state[paginationProp] = scrollProp[paginationProp];
+    state.requestCount += 1;
+    router.remember(
+      {
+        previousPage: state.previousPage,
+        nextPage: state.nextPage,
+        lastLoadedPage: state.lastLoadedPage,
+        requestCount: state.requestCount
+      },
+      getRememberKey()
+    );
   };
   const getPageName = () => getScrollPropFromCurrentPage().pageName;
+  const getRequestCount = () => state.requestCount;
   const fetchPage = (side, reloadOptions = {}) => {
     const page2 = findPageToLoad(side);
     if (state.loading || page2 === null) {
@@ -2480,10 +2515,12 @@ var useInfiniteScrollData = (options) => {
   return {
     getLastLoadedPage,
     getPageName,
+    getRequestCount,
     hasPrevious,
     hasNext,
     fetchNext,
-    fetchPrevious
+    fetchPrevious,
+    removeEventListener
   };
 };
 
@@ -2526,11 +2563,13 @@ var useInfiniteScrollElementManager = (options) => {
     itemsMutationObserver = new MutationObserver((mutations) => {
       mutations.forEach((mutation) => {
         mutation.addedNodes.forEach((node) => {
-          if (node.nodeType === Node.ELEMENT_NODE) {
-            addedElements.add(node);
+          if (node.nodeType !== Node.ELEMENT_NODE) {
+            return;
           }
+          addedElements.add(node);
         });
       });
+      rememberElementsDebounced();
     });
     itemsMutationObserver.observe(options.getItemsElement(), { childList: true });
     itemsObserver = intersectionObservers.new(
@@ -2593,13 +2632,73 @@ var useInfiniteScrollElementManager = (options) => {
       )
     );
   };
+  let hasRestoredElements = false;
   const processServerLoadedElements = (loadedPage) => {
+    if (!hasRestoredElements) {
+      hasRestoredElements = true;
+      if (restoreElements()) {
+        return;
+      }
+    }
     findUntaggedElements(options.getItemsElement()).forEach((element) => {
       if (elementIsUntagged(element)) {
         element.dataset[INFINITE_SCROLL_PAGE_KEY] = loadedPage?.toString() || "1";
       }
       itemsObserver.observe(element);
     });
+    rememberElements();
+  };
+  const getElementsRememberKey = () => `inertia:infinite-scroll-elements:${options.getPropName()}`;
+  const rememberElements = () => {
+    const pageElementRange = {};
+    const childNodes = options.getItemsElement().childNodes;
+    for (let index = 0; index < childNodes.length; index++) {
+      const node = childNodes[index];
+      if (node.nodeType !== Node.ELEMENT_NODE) {
+        continue;
+      }
+      const page2 = getPageFromElement(node);
+      if (typeof page2 === "undefined") {
+        continue;
+      }
+      if (!(page2 in pageElementRange)) {
+        pageElementRange[page2] = { from: index, to: index };
+      } else {
+        pageElementRange[page2].to = index;
+      }
+    }
+    router.remember(pageElementRange, getElementsRememberKey());
+  };
+  const rememberElementsDebounced = debounce(rememberElements, 250);
+  const restoreElements = () => {
+    const pageElementRange = router.restore(getElementsRememberKey());
+    if (!pageElementRange || typeof pageElementRange !== "object") {
+      return false;
+    }
+    const childNodes = options.getItemsElement().childNodes;
+    for (let index = 0; index < childNodes.length; index++) {
+      const node = childNodes[index];
+      if (node.nodeType !== Node.ELEMENT_NODE) {
+        continue;
+      }
+      const element = node;
+      let elementPage;
+      for (const [page2, range] of Object.entries(pageElementRange)) {
+        if (index >= range.from && index <= range.to) {
+          elementPage = page2;
+          break;
+        }
+      }
+      if (elementPage) {
+        element.dataset[INFINITE_SCROLL_PAGE_KEY] = elementPage;
+      } else if (!elementIsUntagged(element)) {
+        continue;
+      } else {
+        element.dataset[INFINITE_SCROLL_IGNORE_KEY] = "true";
+      }
+      itemsObserver.observe(element);
+    }
+    return true;
   };
   return {
     setupObservers,