@inertiajs/core 2.2.18 → 2.2.20

package/dist/index.esm.js

@@ -38,7 +38,8 @@ var config = new Config({
   future: {
     preserveEqualProps: false,
     useDataInertiaHeadAttribute: false,
-    useDialogForErrorModal: false
+    useDialogForErrorModal: false,
+    useScriptElementForInitialPage: false
   },
   prefetch: {
     cacheFor: 3e4,
@@ -97,7 +98,7 @@ var firePrefetchingEvent = (visit) => {
 };
 
 // src/history.ts
-import { cloneDeep, isEqual } from "lodash-es";
+import { cloneDeep as cloneDeep2, isEqual } from "lodash-es";
 
 // src/sessionStorage.ts
 var SessionStorage = class {
@@ -268,6 +269,300 @@ var getKeyFromSessionStorage = async () => {
   return key;
 };
 
+// src/prefetched.ts
+import { cloneDeep } from "lodash-es";
+
+// src/objectUtils.ts
+var objectsAreEqual = (obj1, obj2, excludeKeys) => {
+  if (obj1 === obj2) {
+    return true;
+  }
+  for (const key in obj1) {
+    if (excludeKeys.includes(key)) {
+      continue;
+    }
+    if (obj1[key] === obj2[key]) {
+      continue;
+    }
+    if (!compareValues(obj1[key], obj2[key])) {
+      return false;
+    }
+  }
+  for (const key in obj2) {
+    if (excludeKeys.includes(key)) {
+      continue;
+    }
+    if (!(key in obj1)) {
+      return false;
+    }
+  }
+  return true;
+};
+var compareValues = (value1, value2) => {
+  switch (typeof value1) {
+    case "object":
+      return objectsAreEqual(value1, value2, []);
+    case "function":
+      return value1.toString() === value2.toString();
+    default:
+      return value1 === value2;
+  }
+};
+
+// src/time.ts
+var conversionMap = {
+  ms: 1,
+  s: 1e3,
+  m: 1e3 * 60,
+  h: 1e3 * 60 * 60,
+  d: 1e3 * 60 * 60 * 24
+};
+var timeToMs = (time) => {
+  if (typeof time === "number") {
+    return time;
+  }
+  for (const [unit, conversion] of Object.entries(conversionMap)) {
+    if (time.endsWith(unit)) {
+      return parseFloat(time) * conversion;
+    }
+  }
+  return parseInt(time);
+};
+
+// src/prefetched.ts
+var PrefetchedRequests = class {
+  constructor() {
+    this.cached = [];
+    this.inFlightRequests = [];
+    this.removalTimers = [];
+    this.currentUseId = null;
+  }
+  add(params, sendFunc, { cacheFor, cacheTags }) {
+    const inFlight = this.findInFlight(params);
+    if (inFlight) {
+      return Promise.resolve();
+    }
+    const existing = this.findCached(params);
+    if (!params.fresh && existing && existing.staleTimestamp > Date.now()) {
+      return Promise.resolve();
+    }
+    const [stale, prefetchExpiresIn] = this.extractStaleValues(cacheFor);
+    const promise = new Promise((resolve, reject) => {
+      sendFunc({
+        ...params,
+        onCancel: () => {
+          this.remove(params);
+          params.onCancel();
+          reject();
+        },
+        onError: (error) => {
+          this.remove(params);
+          params.onError(error);
+          reject();
+        },
+        onPrefetching(visitParams) {
+          params.onPrefetching(visitParams);
+        },
+        onPrefetched(response, visit) {
+          params.onPrefetched(response, visit);
+        },
+        onPrefetchResponse(response) {
+          resolve(response);
+        },
+        onPrefetchError(error) {
+          prefetchedRequests.removeFromInFlight(params);
+          reject(error);
+        }
+      });
+    }).then((response) => {
+      this.remove(params);
+      const pageResponse = response.getPageResponse();
+      page.mergeOncePropsIntoResponse(pageResponse);
+      this.cached.push({
+        params: { ...params },
+        staleTimestamp: Date.now() + stale,
+        expiresAt: Date.now() + prefetchExpiresIn,
+        response: promise,
+        singleUse: prefetchExpiresIn === 0,
+        timestamp: Date.now(),
+        inFlight: false,
+        tags: Array.isArray(cacheTags) ? cacheTags : [cacheTags]
+      });
+      const oncePropExpiresIn = this.getShortestOncePropTtl(pageResponse);
+      this.scheduleForRemoval(
+        params,
+        oncePropExpiresIn ? Math.min(prefetchExpiresIn, oncePropExpiresIn) : prefetchExpiresIn
+      );
+      this.removeFromInFlight(params);
+      response.handlePrefetch();
+      return response;
+    });
+    this.inFlightRequests.push({
+      params: { ...params },
+      response: promise,
+      staleTimestamp: null,
+      inFlight: true
+    });
+    return promise;
+  }
+  removeAll() {
+    this.cached = [];
+    this.removalTimers.forEach((removalTimer) => {
+      clearTimeout(removalTimer.timer);
+    });
+    this.removalTimers = [];
+  }
+  removeByTags(tags) {
+    this.cached = this.cached.filter((prefetched) => {
+      return !prefetched.tags.some((tag) => tags.includes(tag));
+    });
+  }
+  remove(params) {
+    this.cached = this.cached.filter((prefetched) => {
+      return !this.paramsAreEqual(prefetched.params, params);
+    });
+    this.clearTimer(params);
+  }
+  removeFromInFlight(params) {
+    this.inFlightRequests = this.inFlightRequests.filter((prefetching) => {
+      return !this.paramsAreEqual(prefetching.params, params);
+    });
+  }
+  extractStaleValues(cacheFor) {
+    const [stale, expires] = this.cacheForToStaleAndExpires(cacheFor);
+    return [timeToMs(stale), timeToMs(expires)];
+  }
+  cacheForToStaleAndExpires(cacheFor) {
+    if (!Array.isArray(cacheFor)) {
+      return [cacheFor, cacheFor];
+    }
+    switch (cacheFor.length) {
+      case 0:
+        return [0, 0];
+      case 1:
+        return [cacheFor[0], cacheFor[0]];
+      default:
+        return [cacheFor[0], cacheFor[1]];
+    }
+  }
+  clearTimer(params) {
+    const timer = this.removalTimers.find((removalTimer) => {
+      return this.paramsAreEqual(removalTimer.params, params);
+    });
+    if (timer) {
+      clearTimeout(timer.timer);
+      this.removalTimers = this.removalTimers.filter((removalTimer) => removalTimer !== timer);
+    }
+  }
+  scheduleForRemoval(params, expiresIn) {
+    if (typeof window === "undefined") {
+      return;
+    }
+    this.clearTimer(params);
+    if (expiresIn > 0) {
+      const timer = window.setTimeout(() => this.remove(params), expiresIn);
+      this.removalTimers.push({
+        params,
+        timer
+      });
+    }
+  }
+  get(params) {
+    return this.findCached(params) || this.findInFlight(params);
+  }
+  use(prefetched, params) {
+    const id = `${params.url.pathname}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    this.currentUseId = id;
+    return prefetched.response.then((response) => {
+      if (this.currentUseId !== id) {
+        return;
+      }
+      response.mergeParams({ ...params, onPrefetched: () => {
+      } });
+      this.removeSingleUseItems(params);
+      return response.handle();
+    });
+  }
+  removeSingleUseItems(params) {
+    this.cached = this.cached.filter((prefetched) => {
+      if (!this.paramsAreEqual(prefetched.params, params)) {
+        return true;
+      }
+      return !prefetched.singleUse;
+    });
+  }
+  findCached(params) {
+    return this.cached.find((prefetched) => {
+      return this.paramsAreEqual(prefetched.params, params);
+    }) || null;
+  }
+  findInFlight(params) {
+    return this.inFlightRequests.find((prefetched) => {
+      return this.paramsAreEqual(prefetched.params, params);
+    }) || null;
+  }
+  withoutPurposePrefetchHeader(params) {
+    const newParams = cloneDeep(params);
+    if (newParams.headers["Purpose"] === "prefetch") {
+      delete newParams.headers["Purpose"];
+    }
+    return newParams;
+  }
+  paramsAreEqual(params1, params2) {
+    return objectsAreEqual(
+      this.withoutPurposePrefetchHeader(params1),
+      this.withoutPurposePrefetchHeader(params2),
+      [
+        "showProgress",
+        "replace",
+        "prefetch",
+        "preserveScroll",
+        "preserveState",
+        "onBefore",
+        "onBeforeUpdate",
+        "onStart",
+        "onProgress",
+        "onFinish",
+        "onCancel",
+        "onSuccess",
+        "onError",
+        "onPrefetched",
+        "onCancelToken",
+        "onPrefetching",
+        "async",
+        "viewTransition"
+      ]
+    );
+  }
+  updateCachedOncePropsFromCurrentPage() {
+    this.cached.forEach((prefetched) => {
+      prefetched.response.then((response) => {
+        const pageResponse = response.getPageResponse();
+        page.mergeOncePropsIntoResponse(pageResponse, { force: true });
+        const oncePropExpiresIn = this.getShortestOncePropTtl(pageResponse);
+        if (oncePropExpiresIn === null) {
+          return;
+        }
+        const prefetchExpiresIn = prefetched.expiresAt - Date.now();
+        const expiresIn = Math.min(prefetchExpiresIn, oncePropExpiresIn);
+        if (expiresIn > 0) {
+          this.scheduleForRemoval(prefetched.params, expiresIn);
+        } else {
+          this.remove(prefetched.params);
+        }
+      });
+    });
+  }
+  getShortestOncePropTtl(page2) {
+    const expiryTimestamps = Object.values(page2.onceProps ?? {}).map((onceProp) => onceProp.expiresAt).filter((expiresAt) => !!expiresAt);
+    if (expiryTimestamps.length === 0) {
+      return null;
+    }
+    return Math.min(...expiryTimestamps) - Date.now();
+  }
+};
+var prefetchedRequests = new PrefetchedRequests();
+
 // src/scroll.ts
 var Scroll = class {
   static save() {
@@ -295,6 +590,10 @@ var Scroll = class {
       }
     });
     this.save();
+    this.scrollToAnchor();
+  }
+  static scrollToAnchor() {
+    const anchorHash = typeof window !== "undefined" ? window.location.hash : null;
     if (anchorHash) {
       setTimeout(() => {
         const anchorElement = document.getElementById(anchorHash.slice(1));
@@ -522,6 +821,9 @@ var CurrentPage = class {
         }
         this.page = page2;
         this.cleared = false;
+        if (this.hasOnceProps()) {
+          prefetchedRequests.updateCachedOncePropsFromCurrentPage();
+        }
         if (isNewComponent) {
           this.fireEventsFor("newComponent");
         }
@@ -570,6 +872,9 @@ var CurrentPage = class {
   get() {
     return this.page;
   }
+  hasOnceProps() {
+    return Object.keys(this.page.onceProps ?? {}).length > 0;
+  }
   merge(data) {
     this.page = { ...this.page, ...data };
   }
@@ -612,6 +917,18 @@ var CurrentPage = class {
   fireEventsFor(event) {
     this.listeners.filter((listener) => listener.event === event).forEach((listener) => listener.callback());
   }
+  mergeOncePropsIntoResponse(response, { force = false } = {}) {
+    Object.entries(response.onceProps ?? {}).forEach(([key, onceProp]) => {
+      const existingOnceProp = this.page.onceProps?.[key];
+      if (existingOnceProp === void 0) {
+        return;
+      }
+      if (force || response.props[onceProp.prop] === void 0) {
+        response.props[onceProp.prop] = this.page.props[existingOnceProp.prop];
+        response.onceProps[key].expiresAt = existingOnceProp.expiresAt;
+      }
+    });
+  }
 };
 var page = new CurrentPage();
 
@@ -695,7 +1012,7 @@ var History = class {
     } catch {
       return {
         ...page2,
-        props: cloneDeep(page2.props)
+        props: cloneDeep2(page2.props)
       };
     }
   }
@@ -798,548 +1115,289 @@ var History = class {
         },
         "",
         url
-      )
-    );
-  }
-  doPushState(data, url) {
-    return Promise.resolve().then(() => window.history.pushState(data, "", url));
-  }
-  getState(key, defaultValue) {
-    return this.current?.[key] ?? defaultValue;
-  }
-  deleteState(key) {
-    if (this.current[key] !== void 0) {
-      delete this.current[key];
-      this.replaceState(this.current);
-    }
-  }
-  clearInitialState(key) {
-    if (this.initialState && this.initialState[key] !== void 0) {
-      delete this.initialState[key];
-    }
-  }
-  hasAnyState() {
-    return !!this.getAllState();
-  }
-  clear() {
-    SessionStorage.remove(historySessionStorageKeys.key);
-    SessionStorage.remove(historySessionStorageKeys.iv);
-  }
-  setCurrent(page2) {
-    this.current = page2;
-  }
-  isValidState(state) {
-    return !!state.page;
-  }
-  getAllState() {
-    return this.current;
-  }
-};
-if (typeof window !== "undefined" && window.history.scrollRestoration) {
-  window.history.scrollRestoration = "manual";
-}
-var history = new History();
-
-// src/eventHandler.ts
-var EventHandler = class {
-  constructor() {
-    this.internalListeners = [];
-  }
-  init() {
-    if (typeof window !== "undefined") {
-      window.addEventListener("popstate", this.handlePopstateEvent.bind(this));
-      window.addEventListener("scroll", debounce(Scroll.onWindowScroll.bind(Scroll), 100), true);
-    }
-    if (typeof document !== "undefined") {
-      document.addEventListener("scroll", debounce(Scroll.onScroll.bind(Scroll), 100), true);
-    }
-  }
-  onGlobalEvent(type, callback) {
-    const listener = ((event) => {
-      const response = callback(event);
-      if (event.cancelable && !event.defaultPrevented && response === false) {
-        event.preventDefault();
-      }
-    });
-    return this.registerListener(`inertia:${type}`, listener);
-  }
-  on(event, callback) {
-    this.internalListeners.push({ event, listener: callback });
-    return () => {
-      this.internalListeners = this.internalListeners.filter((listener) => listener.listener !== callback);
-    };
-  }
-  onMissingHistoryItem() {
-    page.clear();
-    this.fireInternalEvent("missingHistoryItem");
-  }
-  fireInternalEvent(event, ...args) {
-    this.internalListeners.filter((listener) => listener.event === event).forEach((listener) => listener.listener(...args));
-  }
-  registerListener(type, listener) {
-    document.addEventListener(type, listener);
-    return () => document.removeEventListener(type, listener);
-  }
-  handlePopstateEvent(event) {
-    const state = event.state || null;
-    if (state === null) {
-      const url = hrefToUrl(page.get().url);
-      url.hash = window.location.hash;
-      history.replaceState({ ...page.get(), url: url.href });
-      Scroll.reset();
-      return;
-    }
-    if (!history.isValidState(state)) {
-      return this.onMissingHistoryItem();
-    }
-    history.decrypt(state.page).then((data) => {
-      if (page.get().version !== data.version) {
-        this.onMissingHistoryItem();
-        return;
-      }
-      router.cancelAll();
-      page.setQuietly(data, { preserveState: false }).then(() => {
-        Scroll.restore(history.getScrollRegions());
-        fireNavigateEvent(page.get());
-      });
-    }).catch(() => {
-      this.onMissingHistoryItem();
-    });
-  }
-};
-var eventHandler = new EventHandler();
-
-// src/navigationType.ts
-var NavigationType = class {
-  constructor() {
-    this.type = this.resolveType();
-  }
-  resolveType() {
-    if (typeof window === "undefined") {
-      return "navigate";
-    }
-    if (window.performance && window.performance.getEntriesByType && window.performance.getEntriesByType("navigation").length > 0) {
-      return window.performance.getEntriesByType("navigation")[0].type;
-    }
-    return "navigate";
-  }
-  get() {
-    return this.type;
-  }
-  isBackForward() {
-    return this.type === "back_forward";
-  }
-  isReload() {
-    return this.type === "reload";
-  }
-};
-var navigationType = new NavigationType();
-
-// src/initialVisit.ts
-var InitialVisit = class {
-  static handle() {
-    this.clearRememberedStateOnReload();
-    const scenarios = [this.handleBackForward, this.handleLocation, this.handleDefault];
-    scenarios.find((handler) => handler.bind(this)());
-  }
-  static clearRememberedStateOnReload() {
-    if (navigationType.isReload()) {
-      history.deleteState(history.rememberedState);
-      history.clearInitialState(history.rememberedState);
-    }
-  }
-  static handleBackForward() {
-    if (!navigationType.isBackForward() || !history.hasAnyState()) {
-      return false;
-    }
-    const scrollRegions = history.getScrollRegions();
-    history.decrypt().then((data) => {
-      page.set(data, { preserveScroll: true, preserveState: true }).then(() => {
-        Scroll.restore(scrollRegions);
-        fireNavigateEvent(page.get());
-      });
-    }).catch(() => {
-      eventHandler.onMissingHistoryItem();
-    });
-    return true;
-  }
-  /**
-   * @link https://inertiajs.com/redirects#external-redirects
-   */
-  static handleLocation() {
-    if (!SessionStorage.exists(SessionStorage.locationVisitKey)) {
-      return false;
-    }
-    const locationVisit = SessionStorage.get(SessionStorage.locationVisitKey) || {};
-    SessionStorage.remove(SessionStorage.locationVisitKey);
-    if (typeof window !== "undefined") {
-      page.setUrlHash(window.location.hash);
-    }
-    history.decrypt(page.get()).then(() => {
-      const rememberedState = history.getState(history.rememberedState, {});
-      const scrollRegions = history.getScrollRegions();
-      page.remember(rememberedState);
-      page.set(page.get(), {
-        preserveScroll: locationVisit.preserveScroll,
-        preserveState: true
-      }).then(() => {
-        if (locationVisit.preserveScroll) {
-          Scroll.restore(scrollRegions);
-        }
-        fireNavigateEvent(page.get());
-      });
-    }).catch(() => {
-      eventHandler.onMissingHistoryItem();
-    });
-    return true;
-  }
-  static handleDefault() {
-    if (typeof window !== "undefined") {
-      page.setUrlHash(window.location.hash);
-    }
-    page.set(page.get(), { preserveScroll: true, preserveState: true }).then(() => {
-      if (navigationType.isReload()) {
-        Scroll.restore(history.getScrollRegions());
-      }
-      fireNavigateEvent(page.get());
-    });
-  }
-};
-
-// src/poll.ts
-var Poll = class {
-  constructor(interval, cb, options) {
-    this.id = null;
-    this.throttle = false;
-    this.keepAlive = false;
-    this.cbCount = 0;
-    this.keepAlive = options.keepAlive ?? false;
-    this.cb = cb;
-    this.interval = interval;
-    if (options.autoStart ?? true) {
-      this.start();
-    }
+      )
+    );
   }
-  stop() {
-    if (this.id) {
-      clearInterval(this.id);
-    }
+  doPushState(data, url) {
+    return Promise.resolve().then(() => window.history.pushState(data, "", url));
   }
-  start() {
-    if (typeof window === "undefined") {
-      return;
-    }
-    this.stop();
-    this.id = window.setInterval(() => {
-      if (!this.throttle || this.cbCount % 10 === 0) {
-        this.cb();
-      }
-      if (this.throttle) {
-        this.cbCount++;
-      }
-    }, this.interval);
+  getState(key, defaultValue) {
+    return this.current?.[key] ?? defaultValue;
   }
-  isInBackground(hidden) {
-    this.throttle = this.keepAlive ? false : hidden;
-    if (this.throttle) {
-      this.cbCount = 0;
+  deleteState(key) {
+    if (this.current[key] !== void 0) {
+      delete this.current[key];
+      this.replaceState(this.current);
     }
   }
-};
-
-// src/polls.ts
-var Polls = class {
-  constructor() {
-    this.polls = [];
-    this.setupVisibilityListener();
+  clearInitialState(key) {
+    if (this.initialState && this.initialState[key] !== void 0) {
+      delete this.initialState[key];
+    }
   }
-  add(interval, cb, options) {
-    const poll = new Poll(interval, cb, options);
-    this.polls.push(poll);
-    return {
-      stop: () => poll.stop(),
-      start: () => poll.start()
-    };
+  hasAnyState() {
+    return !!this.getAllState();
   }
   clear() {
-    this.polls.forEach((poll) => poll.stop());
-    this.polls = [];
+    SessionStorage.remove(historySessionStorageKeys.key);
+    SessionStorage.remove(historySessionStorageKeys.iv);
   }
-  setupVisibilityListener() {
-    if (typeof document === "undefined") {
-      return;
-    }
-    document.addEventListener(
-      "visibilitychange",
-      () => {
-        this.polls.forEach((poll) => poll.isInBackground(document.hidden));
-      },
-      false
-    );
+  setCurrent(page2) {
+    this.current = page2;
+  }
+  isValidState(state) {
+    return !!state.page;
+  }
+  getAllState() {
+    return this.current;
   }
 };
-var polls = new Polls();
-
-// src/prefetched.ts
-import { cloneDeep as cloneDeep2 } from "lodash-es";
+if (typeof window !== "undefined" && window.history.scrollRestoration) {
+  window.history.scrollRestoration = "manual";
+}
+var history = new History();
 
-// src/objectUtils.ts
-var objectsAreEqual = (obj1, obj2, excludeKeys) => {
-  if (obj1 === obj2) {
-    return true;
+// src/eventHandler.ts
+var EventHandler = class {
+  constructor() {
+    this.internalListeners = [];
   }
-  for (const key in obj1) {
-    if (excludeKeys.includes(key)) {
-      continue;
-    }
-    if (obj1[key] === obj2[key]) {
-      continue;
+  init() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("popstate", this.handlePopstateEvent.bind(this));
+      window.addEventListener("scroll", debounce(Scroll.onWindowScroll.bind(Scroll), 100), true);
     }
-    if (!compareValues(obj1[key], obj2[key])) {
-      return false;
+    if (typeof document !== "undefined") {
+      document.addEventListener("scroll", debounce(Scroll.onScroll.bind(Scroll), 100), true);
     }
   }
-  for (const key in obj2) {
-    if (excludeKeys.includes(key)) {
-      continue;
-    }
-    if (!(key in obj1)) {
-      return false;
-    }
+  onGlobalEvent(type, callback) {
+    const listener = ((event) => {
+      const response = callback(event);
+      if (event.cancelable && !event.defaultPrevented && response === false) {
+        event.preventDefault();
+      }
+    });
+    return this.registerListener(`inertia:${type}`, listener);
   }
-  return true;
-};
-var compareValues = (value1, value2) => {
-  switch (typeof value1) {
-    case "object":
-      return objectsAreEqual(value1, value2, []);
-    case "function":
-      return value1.toString() === value2.toString();
-    default:
-      return value1 === value2;
+  on(event, callback) {
+    this.internalListeners.push({ event, listener: callback });
+    return () => {
+      this.internalListeners = this.internalListeners.filter((listener) => listener.listener !== callback);
+    };
   }
-};
-
-// src/time.ts
-var conversionMap = {
-  ms: 1,
-  s: 1e3,
-  m: 1e3 * 60,
-  h: 1e3 * 60 * 60,
-  d: 1e3 * 60 * 60 * 24
-};
-var timeToMs = (time) => {
-  if (typeof time === "number") {
-    return time;
+  onMissingHistoryItem() {
+    page.clear();
+    this.fireInternalEvent("missingHistoryItem");
   }
-  for (const [unit, conversion] of Object.entries(conversionMap)) {
-    if (time.endsWith(unit)) {
-      return parseFloat(time) * conversion;
+  fireInternalEvent(event, ...args) {
+    this.internalListeners.filter((listener) => listener.event === event).forEach((listener) => listener.listener(...args));
+  }
+  registerListener(type, listener) {
+    document.addEventListener(type, listener);
+    return () => document.removeEventListener(type, listener);
+  }
+  handlePopstateEvent(event) {
+    const state = event.state || null;
+    if (state === null) {
+      const url = hrefToUrl(page.get().url);
+      url.hash = window.location.hash;
+      history.replaceState({ ...page.get(), url: url.href });
+      Scroll.reset();
+      return;
+    }
+    if (!history.isValidState(state)) {
+      return this.onMissingHistoryItem();
     }
+    history.decrypt(state.page).then((data) => {
+      if (page.get().version !== data.version) {
+        this.onMissingHistoryItem();
+        return;
+      }
+      router.cancelAll();
+      page.setQuietly(data, { preserveState: false }).then(() => {
+        Scroll.restore(history.getScrollRegions());
+        fireNavigateEvent(page.get());
+      });
+    }).catch(() => {
+      this.onMissingHistoryItem();
+    });
   }
-  return parseInt(time);
 };
+var eventHandler = new EventHandler();
 
-// src/prefetched.ts
-var PrefetchedRequests = class {
+// src/navigationType.ts
+var NavigationType = class {
   constructor() {
-    this.cached = [];
-    this.inFlightRequests = [];
-    this.removalTimers = [];
-    this.currentUseId = null;
+    this.type = this.resolveType();
   }
-  add(params, sendFunc, { cacheFor, cacheTags }) {
-    const inFlight = this.findInFlight(params);
-    if (inFlight) {
-      return Promise.resolve();
+  resolveType() {
+    if (typeof window === "undefined") {
+      return "navigate";
     }
-    const existing = this.findCached(params);
-    if (!params.fresh && existing && existing.staleTimestamp > Date.now()) {
-      return Promise.resolve();
+    if (window.performance && window.performance.getEntriesByType && window.performance.getEntriesByType("navigation").length > 0) {
+      return window.performance.getEntriesByType("navigation")[0].type;
     }
-    const [stale, expires] = this.extractStaleValues(cacheFor);
-    const promise = new Promise((resolve, reject) => {
-      sendFunc({
-        ...params,
-        onCancel: () => {
-          this.remove(params);
-          params.onCancel();
-          reject();
-        },
-        onError: (error) => {
-          this.remove(params);
-          params.onError(error);
-          reject();
-        },
-        onPrefetching(visitParams) {
-          params.onPrefetching(visitParams);
-        },
-        onPrefetched(response, visit) {
-          params.onPrefetched(response, visit);
-        },
-        onPrefetchResponse(response) {
-          resolve(response);
-        },
-        onPrefetchError(error) {
-          prefetchedRequests.removeFromInFlight(params);
-          reject(error);
-        }
-      });
-    }).then((response) => {
-      this.remove(params);
-      this.cached.push({
-        params: { ...params },
-        staleTimestamp: Date.now() + stale,
-        response: promise,
-        singleUse: expires === 0,
-        timestamp: Date.now(),
-        inFlight: false,
-        tags: Array.isArray(cacheTags) ? cacheTags : [cacheTags]
-      });
-      this.scheduleForRemoval(params, expires);
-      this.removeFromInFlight(params);
-      response.handlePrefetch();
-      return response;
-    });
-    this.inFlightRequests.push({
-      params: { ...params },
-      response: promise,
-      staleTimestamp: null,
-      inFlight: true
-    });
-    return promise;
+    return "navigate";
+  }
+  get() {
+    return this.type;
   }
-  removeAll() {
-    this.cached = [];
-    this.removalTimers.forEach((removalTimer) => {
-      clearTimeout(removalTimer.timer);
-    });
-    this.removalTimers = [];
+  isBackForward() {
+    return this.type === "back_forward";
   }
-  removeByTags(tags) {
-    this.cached = this.cached.filter((prefetched) => {
-      return !prefetched.tags.some((tag) => tags.includes(tag));
-    });
+  isReload() {
+    return this.type === "reload";
   }
-  remove(params) {
-    this.cached = this.cached.filter((prefetched) => {
-      return !this.paramsAreEqual(prefetched.params, params);
-    });
-    this.clearTimer(params);
+};
+var navigationType = new NavigationType();
+
+// src/initialVisit.ts
+var InitialVisit = class {
+  static handle() {
+    this.clearRememberedStateOnReload();
+    const scenarios = [this.handleBackForward, this.handleLocation, this.handleDefault];
+    scenarios.find((handler) => handler.bind(this)());
   }
-  removeFromInFlight(params) {
-    this.inFlightRequests = this.inFlightRequests.filter((prefetching) => {
-      return !this.paramsAreEqual(prefetching.params, params);
-    });
+  static clearRememberedStateOnReload() {
+    if (navigationType.isReload()) {
+      history.deleteState(history.rememberedState);
+      history.clearInitialState(history.rememberedState);
+    }
   }
-  extractStaleValues(cacheFor) {
-    const [stale, expires] = this.cacheForToStaleAndExpires(cacheFor);
-    return [timeToMs(stale), timeToMs(expires)];
+  static handleBackForward() {
+    if (!navigationType.isBackForward() || !history.hasAnyState()) {
+      return false;
+    }
+    const scrollRegions = history.getScrollRegions();
+    history.decrypt().then((data) => {
+      page.set(data, { preserveScroll: true, preserveState: true }).then(() => {
+        Scroll.restore(scrollRegions);
+        fireNavigateEvent(page.get());
+      });
+    }).catch(() => {
+      eventHandler.onMissingHistoryItem();
+    });
+    return true;
   }
-  cacheForToStaleAndExpires(cacheFor) {
-    if (!Array.isArray(cacheFor)) {
-      return [cacheFor, cacheFor];
+  /**
+   * @link https://inertiajs.com/redirects#external-redirects
+   */
+  static handleLocation() {
+    if (!SessionStorage.exists(SessionStorage.locationVisitKey)) {
+      return false;
     }
-    switch (cacheFor.length) {
-      case 0:
-        return [0, 0];
-      case 1:
-        return [cacheFor[0], cacheFor[0]];
-      default:
-        return [cacheFor[0], cacheFor[1]];
+    const locationVisit = SessionStorage.get(SessionStorage.locationVisitKey) || {};
+    SessionStorage.remove(SessionStorage.locationVisitKey);
+    if (typeof window !== "undefined") {
+      page.setUrlHash(window.location.hash);
     }
+    history.decrypt(page.get()).then(() => {
+      const rememberedState = history.getState(history.rememberedState, {});
+      const scrollRegions = history.getScrollRegions();
+      page.remember(rememberedState);
+      page.set(page.get(), {
+        preserveScroll: locationVisit.preserveScroll,
+        preserveState: true
+      }).then(() => {
+        if (locationVisit.preserveScroll) {
+          Scroll.restore(scrollRegions);
+        }
+        fireNavigateEvent(page.get());
+      });
+    }).catch(() => {
+      eventHandler.onMissingHistoryItem();
+    });
+    return true;
   }
-  clearTimer(params) {
-    const timer = this.removalTimers.find((removalTimer) => {
-      return this.paramsAreEqual(removalTimer.params, params);
+  static handleDefault() {
+    if (typeof window !== "undefined") {
+      page.setUrlHash(window.location.hash);
+    }
+    page.set(page.get(), { preserveScroll: true, preserveState: true }).then(() => {
+      if (navigationType.isReload()) {
+        Scroll.restore(history.getScrollRegions());
+      } else {
+        Scroll.scrollToAnchor();
+      }
+      fireNavigateEvent(page.get());
     });
-    if (timer) {
-      clearTimeout(timer.timer);
-      this.removalTimers = this.removalTimers.filter((removalTimer) => removalTimer !== timer);
+  }
+};
+
+// src/poll.ts
+var Poll = class {
+  constructor(interval, cb, options) {
+    this.id = null;
+    this.throttle = false;
+    this.keepAlive = false;
+    this.cbCount = 0;
+    this.keepAlive = options.keepAlive ?? false;
+    this.cb = cb;
+    this.interval = interval;
+    if (options.autoStart ?? true) {
+      this.start();
     }
   }
-  scheduleForRemoval(params, expiresIn) {
+  stop() {
+    if (this.id) {
+      clearInterval(this.id);
+    }
+  }
+  start() {
     if (typeof window === "undefined") {
       return;
     }
-    this.clearTimer(params);
-    if (expiresIn > 0) {
-      const timer = window.setTimeout(() => this.remove(params), expiresIn);
-      this.removalTimers.push({
-        params,
-        timer
-      });
-    }
-  }
-  get(params) {
-    return this.findCached(params) || this.findInFlight(params);
-  }
-  use(prefetched, params) {
-    const id = `${params.url.pathname}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    this.currentUseId = id;
-    return prefetched.response.then((response) => {
-      if (this.currentUseId !== id) {
-        return;
+    this.stop();
+    this.id = window.setInterval(() => {
+      if (!this.throttle || this.cbCount % 10 === 0) {
+        this.cb();
       }
-      response.mergeParams({ ...params, onPrefetched: () => {
-      } });
-      this.removeSingleUseItems(params);
-      return response.handle();
-    });
-  }
-  removeSingleUseItems(params) {
-    this.cached = this.cached.filter((prefetched) => {
-      if (!this.paramsAreEqual(prefetched.params, params)) {
-        return true;
+      if (this.throttle) {
+        this.cbCount++;
       }
-      return !prefetched.singleUse;
-    });
+    }, this.interval);
   }
-  findCached(params) {
-    return this.cached.find((prefetched) => {
-      return this.paramsAreEqual(prefetched.params, params);
-    }) || null;
+  isInBackground(hidden) {
+    this.throttle = this.keepAlive ? false : hidden;
+    if (this.throttle) {
+      this.cbCount = 0;
+    }
   }
-  findInFlight(params) {
-    return this.inFlightRequests.find((prefetched) => {
-      return this.paramsAreEqual(prefetched.params, params);
-    }) || null;
+};
+
+// src/polls.ts
+var Polls = class {
+  constructor() {
+    this.polls = [];
+    this.setupVisibilityListener();
   }
-  withoutPurposePrefetchHeader(params) {
-    const newParams = cloneDeep2(params);
-    if (newParams.headers["Purpose"] === "prefetch") {
-      delete newParams.headers["Purpose"];
-    }
-    return newParams;
+  add(interval, cb, options) {
+    const poll = new Poll(interval, cb, options);
+    this.polls.push(poll);
+    return {
+      stop: () => poll.stop(),
+      start: () => poll.start()
+    };
   }
-  paramsAreEqual(params1, params2) {
-    return objectsAreEqual(
-      this.withoutPurposePrefetchHeader(params1),
-      this.withoutPurposePrefetchHeader(params2),
-      [
-        "showProgress",
-        "replace",
-        "prefetch",
-        "preserveScroll",
-        "preserveState",
-        "onBefore",
-        "onBeforeUpdate",
-        "onStart",
-        "onProgress",
-        "onFinish",
-        "onCancel",
-        "onSuccess",
-        "onError",
-        "onPrefetched",
-        "onCancelToken",
-        "onPrefetching",
-        "async",
-        "viewTransition"
-      ]
+  clear() {
+    this.polls.forEach((poll) => poll.stop());
+    this.polls = [];
+  }
+  setupVisibilityListener() {
+    if (typeof document === "undefined") {
+      return;
+    }
+    document.addEventListener(
+      "visibilitychange",
+      () => {
+        this.polls.forEach((poll) => poll.isInBackground(document.hidden));
+      },
+      false
     );
   }
 };
-var prefetchedRequests = new PrefetchedRequests();
+var polls = new Polls();
 
 // src/request.ts
 import { default as axios } from "axios";
@@ -1386,6 +1444,9 @@ var RequestParams = class _RequestParams {
   isPartial() {
     return this.params.only.length > 0 || this.params.except.length > 0 || this.params.reset.length > 0;
   }
+  isDeferredPropsRequest() {
+    return this.params.deferredProps === true;
+  }
   onCancelToken(cb) {
     this.params.onCancelToken({
       cancel: cb
@@ -1644,6 +1705,9 @@ var Response = class _Response {
   mergeParams(params) {
     this.requestParams.merge(params);
   }
+  getPageResponse() {
+    return this.response.data = this.getDataFromResponse(this.response.data);
+  }
   async handleNonInertiaResponse() {
     if (this.isLocationVisit()) {
       const locationUrl = hrefToUrl(this.getHeader("x-inertia-location"));
@@ -1694,11 +1758,12 @@ var Response = class _Response {
     }
   }
   async setPage() {
-    const pageResponse = this.getDataFromResponse(this.response.data);
+    const pageResponse = this.getPageResponse();
     if (!this.shouldSetPage(pageResponse)) {
       return Promise.resolve();
     }
     this.mergeProps(pageResponse);
+    page.mergeOncePropsIntoResponse(pageResponse);
     this.preserveEqualProps(pageResponse);
     await this.setRememberedState(pageResponse);
     this.requestParams.setPreserveOptions(pageResponse);
@@ -1803,6 +1868,12 @@ var Response = class _Response {
       pageResponse.props[prop] = deepMerge(currentProp, incomingProp, prop);
     });
     pageResponse.props = { ...page.get().props, ...pageResponse.props };
+    if (this.requestParams.isDeferredPropsRequest()) {
+      const currentErrors = page.get().props.errors;
+      if (currentErrors && Object.keys(currentErrors).length > 0) {
+        pageResponse.props.errors = currentErrors;
+      }
+    }
     if (page.get().scrollProps) {
       pageResponse.scrollProps = {
         ...page.get().scrollProps || {},
@@ -1965,8 +2036,13 @@ var Request = class _Request {
       "X-Requested-With": "XMLHttpRequest",
       "X-Inertia": true
     };
-    if (page.get().version) {
-      headers["X-Inertia-Version"] = page.get().version;
+    const page2 = page.get();
+    if (page2.version) {
+      headers["X-Inertia-Version"] = page2.version;
+    }
+    const onceProps = Object.entries(page2.onceProps || {}).filter(([, onceProp]) => !onceProp.expiresAt || onceProp.expiresAt > Date.now()).map(([key]) => key);
+    if (onceProps.length > 0) {
+      headers["X-Inertia-Except-Once-Props"] = onceProps.join(",");
     }
     return headers;
   }
@@ -2017,6 +2093,7 @@ var Router = class {
       maxConcurrent: Infinity,
       interruptible: false
     });
+    this.clientVisitQueue = new Queue();
   }
   init({
     initialPage,
@@ -2055,6 +2132,9 @@ var Router = class {
     return this.visit(url, { preserveState: true, ...options, method: "delete" });
   }
   reload(options = {}) {
+    return this.doReload(options);
+  }
+  doReload(options = {}) {
     if (typeof window === "undefined") {
       return;
     }
@@ -2243,6 +2323,9 @@ var Router = class {
     this.clientVisit(params);
   }
   clientVisit(params, { replace = false } = {}) {
+    this.clientVisitQueue.add(() => this.performClientVisit(params, { replace }));
+  }
+  performClientVisit(params, { replace = false } = {}) {
     const current = page.get();
     const props = typeof params.props === "function" ? params.props(current.props) : params.props ?? current.props;
     const { viewTransition, onError, onFinish, onSuccess, ...pageParams } = params;
@@ -2253,7 +2336,7 @@ var Router = class {
     };
     const preserveScroll = RequestParams.resolvePreserveOption(params.preserveScroll ?? false, page2);
     const preserveState = RequestParams.resolvePreserveOption(params.preserveState ?? false, page2);
-    page.set(page2, {
+    return page.set(page2, {
       replace,
       preserveScroll,
       preserveState,
@@ -2261,10 +2344,11 @@ var Router = class {
     }).then(() => {
       const errors = page.get().props.errors || {};
       if (Object.keys(errors).length === 0) {
-        return onSuccess?.(page.get());
+        onSuccess?.(page.get());
+        return;
       }
       const scopedErrors = params.errorBag ? errors[params.errorBag || ""] || {} : errors;
-      return onError?.(scopedErrors);
+      onError?.(scopedErrors);
     }).finally(() => onFinish?.(params));
   }
   getPrefetchParams(href, options) {
@@ -2360,7 +2444,7 @@ var Router = class {
   loadDeferredProps(deferred) {
     if (deferred) {
       Object.entries(deferred).forEach(([_, group]) => {
-        this.reload({ only: group });
+        this.doReload({ only: group, deferredProps: true });
       });
     }
   }
@@ -2456,6 +2540,22 @@ var requestAnimationFrame = (cb, times = 1) => {
     }
   });
 };
+var getInitialPageFromDOM = (id, useScriptElement = false) => {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (!useScriptElement) {
+    const el = document.getElementById(id);
+    if (el?.dataset.page) {
+      return JSON.parse(el.dataset.page);
+    }
+  }
+  const scriptEl = document.querySelector(`script[data-page="${id}"][type="application/json"]`);
+  if (scriptEl?.textContent) {
+    return JSON.parse(scriptEl.textContent);
+  }
+  return null;
+};
 
 // src/formObject.ts
 import { get as get4, set as set4 } from "lodash-es";
@@ -3683,6 +3783,7 @@ export {
   config,
   createHeadManager,
   formDataToObject,
+  getInitialPageFromDOM,
   getScrollableParent,
   hide2 as hideProgress,
   hrefToUrl,