@inertiajs/react 2.3.17 → 3.0.0-beta.2

package/dist/index.js

@@ -1,74 +1,74 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  App: () => App,
-  Deferred: () => Deferred_default,
-  Form: () => Form_default,
-  Head: () => Head_default,
-  InfiniteScroll: () => InfiniteScroll_default,
-  Link: () => Link_default,
-  WhenVisible: () => WhenVisible_default,
-  config: () => config,
-  createInertiaApp: () => createInertiaApp,
-  progress: () => progress,
-  router: () => router3,
-  useForm: () => useForm,
-  useFormContext: () => useFormContext,
-  usePage: () => usePage,
-  usePoll: () => usePoll,
-  usePrefetch: () => usePrefetch,
-  useRemember: () => useRemember
-});
-module.exports = __toCommonJS(index_exports);
-var import_core11 = require("@inertiajs/core");
+import { config as coreConfig } from "@inertiajs/core";
+import { http as http2, progress, router as router3 } from "@inertiajs/core";
 
 // src/App.ts
-var import_core = require("@inertiajs/core");
-var import_react3 = require("react");
-var import_react_dom = require("react-dom");
+import {
+  createHeadManager,
+  normalizeLayouts,
+  router
+} from "@inertiajs/core";
+import { createElement, useEffect, useMemo as useMemo2, useState } from "react";
+import { flushSync } from "react-dom";
 
 // src/HeadContext.ts
-var import_react = require("react");
-var headContext = (0, import_react.createContext)(null);
+import { createContext } from "react";
+var headContext = createContext(null);
 headContext.displayName = "InertiaHeadContext";
 var HeadContext_default = headContext;
 
+// src/layoutProps.ts
+import { createLayoutPropsStore, mergeLayoutProps } from "@inertiajs/core";
+import { createContext as createContext2, useContext, useMemo, useSyncExternalStore } from "react";
+var store = createLayoutPropsStore();
+function setLayoutProps(props) {
+  store.set(props);
+}
+function setLayoutPropsFor(name, props) {
+  store.setFor(name, props);
+}
+function resetLayoutProps() {
+  store.reset();
+}
+var LayoutPropsContext = createContext2({
+  staticProps: {}
+});
+function useLayoutProps(defaults) {
+  const { staticProps, name } = useContext(LayoutPropsContext);
+  const { shared, named } = useSyncExternalStore(store.subscribe, store.get, store.get);
+  return useMemo(() => {
+    const dynamicProps = name ? { ...shared, ...named[name] } : shared;
+    return mergeLayoutProps(defaults, staticProps, dynamicProps);
+  }, [defaults, staticProps, name, shared, named]);
+}
+
 // src/PageContext.ts
-var import_react2 = require("react");
-var pageContext = (0, import_react2.createContext)(null);
+import { createContext as createContext3 } from "react";
+var pageContext = createContext3(null);
 pageContext.displayName = "InertiaPageContext";
 var PageContext_default = pageContext;
 
 // src/App.ts
+function isComponent(value) {
+  if (!value) {
+    return false;
+  }
+  if (typeof value === "object" && "$$typeof" in value) {
+    return true;
+  }
+  if (typeof value === "function") {
+    const fn = value;
+    return fn.prototype?.isReactComponent === true || fn.name !== "" || fn.displayName !== void 0;
+  }
+  return false;
+}
+function isRenderFunction(value) {
+  if (typeof value !== "function") {
+    return false;
+  }
+  const fn = value;
+  return fn.length === 1 && typeof fn.prototype === "undefined";
+}
 var currentIsInitialPage = true;
 var routerIsInitialized = false;
 var swapComponent = async () => {
@@ -80,15 +80,16 @@ function App({
   initialComponent,
   resolveComponent,
   titleCallback,
-  onHeadUpdate
+  onHeadUpdate,
+  defaultLayout
 }) {
-  const [current, setCurrent] = (0, import_react3.useState)({
+  const [current, setCurrent] = useState({
     component: initialComponent || null,
     page: { ...initialPage, flash: initialPage.flash ?? {} },
     key: null
   });
-  const headManager = (0, import_react3.useMemo)(() => {
-    return (0, import_core.createHeadManager)(
+  const headManager = useMemo2(() => {
+    return createHeadManager(
       typeof window === "undefined",
       titleCallback || ((title) => title),
       onHeadUpdate || (() => {
@@ -96,7 +97,7 @@ function App({
     );
   }, []);
   if (!routerIsInitialized) {
-    import_core.router.init({
+    router.init({
       initialPage,
       resolveComponent,
       swapComponent: async (args) => swapComponent(args),
@@ -109,13 +110,16 @@ function App({
     });
     routerIsInitialized = true;
   }
-  (0, import_react3.useEffect)(() => {
+  useEffect(() => {
     swapComponent = async ({ component, page, preserveState }) => {
       if (currentIsInitialPage) {
         currentIsInitialPage = false;
         return;
       }
-      (0, import_react_dom.flushSync)(
+      if (!preserveState) {
+        resetLayoutProps();
+      }
+      flushSync(
         () => setCurrent((current2) => ({
           component,
           page,
@@ -123,29 +127,37 @@ function App({
         }))
       );
     };
-    import_core.router.on("navigate", () => headManager.forceUpdate());
+    router.on("navigate", () => headManager.forceUpdate());
   }, []);
   if (!current.component) {
-    return (0, import_react3.createElement)(
+    return createElement(
       HeadContext_default.Provider,
       { value: headManager },
-      (0, import_react3.createElement)(PageContext_default.Provider, { value: current.page }, null)
+      createElement(PageContext_default.Provider, { value: current.page }, null)
     );
   }
   const renderChildren = children || (({ Component, props, key }) => {
-    const child = (0, import_react3.createElement)(Component, { key, ...props });
-    if (typeof Component.layout === "function") {
+    const child = createElement(Component, { key, ...props });
+    if (Component.layout && isRenderFunction(Component.layout)) {
       return Component.layout(child);
     }
-    if (Array.isArray(Component.layout)) {
-      return Component.layout.concat(child).reverse().reduce((children2, Layout) => (0, import_react3.createElement)(Layout, { children: children2, ...props }));
+    const effectiveLayout = Component.layout ?? defaultLayout?.(current.page.component, current.page);
+    const layouts = normalizeLayouts(effectiveLayout, isComponent, Component.layout ? isRenderFunction : void 0);
+    if (layouts.length > 0) {
+      return layouts.reduceRight((childNode, layout) => {
+        return createElement(
+          LayoutPropsContext.Provider,
+          { value: { staticProps: { ...props, ...layout.props }, name: layout.name } },
+          createElement(layout.component, { ...props, ...layout.props }, childNode)
+        );
+      }, child);
     }
     return child;
   });
-  return (0, import_react3.createElement)(
+  return createElement(
     HeadContext_default.Provider,
     { value: headManager },
-    (0, import_react3.createElement)(
+    createElement(
       PageContext_default.Provider,
       { value: current.page },
       renderChildren({
@@ -159,8 +171,15 @@ function App({
 App.displayName = "Inertia";
 
 // src/createInertiaApp.ts
-var import_core2 = require("@inertiajs/core");
-var import_react4 = require("react");
+import {
+  buildSSRBody,
+  getInitialPageFromDOM,
+  http as httpModule,
+  router as router2,
+  setupProgress
+} from "@inertiajs/core";
+import { createElement as createElement2, StrictMode } from "react";
+import { createRoot, hydrateRoot } from "react-dom/client";
 async function createInertiaApp({
   id = "app",
   resolve,
@@ -169,87 +188,105 @@ async function createInertiaApp({
   progress: progress2 = {},
   page,
   render,
-  defaults = {}
-}) {
+  defaults = {},
+  http: http3,
+  layout,
+  strictMode = false
+} = {}) {
   config.replace(defaults);
+  if (http3) {
+    httpModule.setClient(http3);
+  }
   const isServer = typeof window === "undefined";
-  const useScriptElementForInitialPage = config.get("future.useScriptElementForInitialPage");
-  const initialPage = page || (0, import_core2.getInitialPageFromDOM)(id, useScriptElementForInitialPage);
-  const resolveComponent = (name) => Promise.resolve(resolve(name)).then((module2) => module2.default || module2);
+  const wrapWithStrictMode = (element) => {
+    return strictMode ? createElement2(StrictMode, null, element) : element;
+  };
+  const resolveComponent = (name, page2) => Promise.resolve(resolve(name, page2)).then((module) => {
+    return module.default || module;
+  });
+  if (isServer && !page && !render) {
+    return async (page2, renderToString) => {
+      let head2 = [];
+      const initialComponent = await resolveComponent(page2.component, page2);
+      const props = {
+        initialPage: page2,
+        initialComponent,
+        resolveComponent,
+        titleCallback: title,
+        onHeadUpdate: (elements) => head2 = elements,
+        defaultLayout: layout
+      };
+      let reactApp2;
+      if (setup) {
+        reactApp2 = setup({
+          el: null,
+          App,
+          props
+        });
+      } else {
+        reactApp2 = wrapWithStrictMode(createElement2(App, props));
+      }
+      const html = renderToString(reactApp2);
+      const body = buildSSRBody(id, page2, html);
+      return { head: head2, body };
+    };
+  }
+  const initialPage = page || getInitialPageFromDOM(id);
   let head = [];
   const reactApp = await Promise.all([
-    resolveComponent(initialPage.component),
-    import_core2.router.decryptHistory().catch(() => {
+    resolveComponent(initialPage.component, initialPage),
+    router2.decryptHistory().catch(() => {
     })
   ]).then(([initialComponent]) => {
     const props = {
       initialPage,
       initialComponent,
       resolveComponent,
-      titleCallback: title
+      titleCallback: title,
+      onHeadUpdate: isServer ? (elements) => head = elements : void 0,
+      defaultLayout: layout
     };
     if (isServer) {
-      const ssrSetup = setup;
-      return ssrSetup({
+      return setup({
         el: null,
         App,
-        props: { ...props, onHeadUpdate: (elements) => head = elements }
+        props
       });
     }
-    const csrSetup = setup;
-    return csrSetup({
-      el: document.getElementById(id),
-      App,
-      props
-    });
+    const el = document.getElementById(id);
+    if (setup) {
+      return setup({
+        el,
+        App,
+        props
+      });
+    }
+    const appElement = wrapWithStrictMode(createElement2(App, props));
+    if (el.hasAttribute("data-server-rendered")) {
+      hydrateRoot(el, appElement);
+    } else {
+      createRoot(el).render(appElement);
+    }
   });
   if (!isServer && progress2) {
-    (0, import_core2.setupProgress)(progress2);
+    setupProgress(progress2);
   }
-  if (isServer && render) {
-    const element = () => {
-      if (!useScriptElementForInitialPage) {
-        return (0, import_react4.createElement)(
-          "div",
-          {
-            id,
-            "data-page": JSON.stringify(initialPage)
-          },
-          reactApp
-        );
-      }
-      return (0, import_react4.createElement)(
-        import_react4.Fragment,
-        null,
-        (0, import_react4.createElement)("script", {
-          "data-page": id,
-          type: "application/json",
-          dangerouslySetInnerHTML: { __html: JSON.stringify(initialPage).replace(/\//g, "\\/") }
-        }),
-        (0, import_react4.createElement)("div", { id }, reactApp)
-      );
-    };
-    const body = await render(element());
+  if (isServer && render && reactApp) {
+    const html = render(reactApp);
+    const body = buildSSRBody(id, initialPage, html);
     return { head, body };
   }
 }
 
 // src/Deferred.ts
-var import_react8 = require("react");
-
-// src/usePage.ts
-var import_react6 = __toESM(require("react"), 1);
-
-// src/react.ts
-var import_react5 = __toESM(require("react"), 1);
-function useIsomorphicLayoutEffect(effect, deps) {
-  typeof window === "undefined" ? (0, import_react5.useEffect)(effect, deps) : (0, import_react5.useLayoutEffect)(effect, deps);
-}
-var isReact19 = typeof import_react5.default.use === "function";
+import { isSameUrlWithoutQueryOrHash } from "@inertiajs/core";
+import { get } from "lodash-es";
+import { useEffect as useEffect2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
 
 // src/usePage.ts
+import { use } from "react";
 function usePage() {
-  const page = isReact19 ? import_react6.default.use(PageContext_default) : import_react6.default.useContext(PageContext_default);
+  const page = use(PageContext_default);
   if (!page) {
     throw new Error("usePage must be used within the Inertia component");
   }
@@ -257,39 +294,54 @@ function usePage() {
 }
 
 // src/Deferred.ts
-var urlWithoutHash = (url) => {
-  url = new URL(url.href);
-  url.hash = "";
-  return url;
-};
-var isSameUrlWithoutHash = (url1, url2) => {
-  return urlWithoutHash(url1).href === urlWithoutHash(url2).href;
+var keysAreBeingReloaded = (only, except, keys) => {
+  if (only.length === 0 && except.length === 0) {
+    return true;
+  }
+  if (only.length > 0) {
+    return keys.some((key) => only.includes(key));
+  }
+  return keys.some((key) => !except.includes(key));
 };
 var Deferred = ({ children, data, fallback }) => {
   if (!data) {
     throw new Error("`<Deferred>` requires a `data` prop to be a string or array of strings");
   }
-  const [loaded, setLoaded] = (0, import_react8.useState)(false);
+  const [loaded, setLoaded] = useState2(false);
+  const [reloading, setReloading] = useState2(false);
+  const activeReloads = useRef(/* @__PURE__ */ new Set());
   const pageProps = usePage().props;
-  const keys = (0, import_react8.useMemo)(() => Array.isArray(data) ? data : [data], [data]);
-  (0, import_react8.useEffect)(() => {
-    const removeListener = router3.on("start", (e) => {
-      const isPartialVisit = e.detail.visit.only.length > 0 || e.detail.visit.except.length > 0;
-      const isReloadingKey = e.detail.visit.only.find((key) => keys.includes(key));
-      if (isSameUrlWithoutHash(e.detail.visit.url, window.location) && (!isPartialVisit || isReloadingKey)) {
-        setLoaded(false);
+  const keys = useMemo3(() => Array.isArray(data) ? data : [data], [data]);
+  useEffect2(() => {
+    const removeStartListener = router3.on("start", (e) => {
+      const visit = e.detail.visit;
+      if (visit.preserveState === true && isSameUrlWithoutQueryOrHash(visit.url, window.location) && keysAreBeingReloaded(visit.only, visit.except, keys)) {
+        activeReloads.current.add(visit);
+        setReloading(true);
+      }
+    });
+    const removeFinishListener = router3.on("finish", (e) => {
+      const visit = e.detail.visit;
+      if (activeReloads.current.has(visit)) {
+        activeReloads.current.delete(visit);
+        setReloading(activeReloads.current.size > 0);
       }
     });
     return () => {
-      removeListener();
+      removeStartListener();
+      removeFinishListener();
+      activeReloads.current.clear();
     };
-  }, []);
-  (0, import_react8.useEffect)(() => {
-    setLoaded(keys.every((key) => pageProps[key] !== void 0));
+  }, [keys]);
+  useEffect2(() => {
+    setLoaded(keys.every((key) => get(pageProps, key) !== void 0));
   }, [pageProps, keys]);
-  const propsAreDefined = (0, import_react8.useMemo)(() => keys.every((key) => pageProps[key] !== void 0), [keys, pageProps]);
+  const propsAreDefined = useMemo3(() => keys.every((key) => get(pageProps, key) !== void 0), [keys, pageProps]);
   if (loaded && propsAreDefined) {
-    return typeof children === "function" ? children() : children;
+    if (typeof children === "function") {
+      return children({ reloading });
+    }
+    return children;
   }
   return typeof fallback === "function" ? fallback() : fallback;
 };
@@ -297,170 +349,93 @@ Deferred.displayName = "InertiaDeferred";
 var Deferred_default = Deferred;
 
 // src/Form.ts
-var import_core5 = require("@inertiajs/core");
-var import_lodash_es2 = require("lodash-es");
-var import_react12 = __toESM(require("react"), 1);
+import {
+  config as config2,
+  FormComponentResetSymbol,
+  formDataToObject,
+  isUrlMethodPair,
+  mergeDataIntoQueryString,
+  resetFormFields,
+  resolveUrlMethodPairComponent,
+  UseFormUtils as UseFormUtils3
+} from "@inertiajs/core";
+import { isEqual as isEqual2 } from "lodash-es";
+import React, {
+  createContext as createContext4,
+  createElement as createElement3,
+  forwardRef,
+  use as use2,
+  useEffect as useEffect6,
+  useImperativeHandle,
+  useMemo as useMemo5,
+  useRef as useRef4,
+  useState as useState6
+} from "react";
 
 // src/useForm.ts
-var import_core4 = require("@inertiajs/core");
-var import_laravel_precognition = require("laravel-precognition");
-var import_lodash_es = require("lodash-es");
-var import_react10 = require("react");
+import {
+  router as router5,
+  UseFormUtils as UseFormUtils2
+} from "@inertiajs/core";
+import { cloneDeep as cloneDeep2 } from "lodash-es";
+import { useCallback as useCallback2, useRef as useRef3, useState as useState5 } from "react";
 
-// src/useRemember.ts
-var import_core3 = require("@inertiajs/core");
-var import_react9 = require("react");
-function useRemember(initialState, key, excludeKeysRef) {
-  const [state, setState] = (0, import_react9.useState)(() => {
-    const restored = import_core3.router.restore(key);
-    return restored !== void 0 ? restored : initialState;
-  });
-  (0, import_react9.useEffect)(() => {
-    const keys = excludeKeysRef?.current;
-    if (keys && keys.length > 0 && typeof state === "object" && state !== null) {
-      const filtered = { ...state };
-      keys.forEach((k) => delete filtered[k]);
-      import_core3.router.remember(filtered, key);
-    } else {
-      import_core3.router.remember(state, key);
-    }
-  }, [state, key]);
-  return [state, setState];
+// src/react.ts
+import { useEffect as useEffect3, useLayoutEffect } from "react";
+function useIsomorphicLayoutEffect(effect, deps) {
+  typeof window === "undefined" ? useEffect3(effect, deps) : useLayoutEffect(effect, deps);
 }
 
-// src/useForm.ts
-function useForm(...args) {
-  const isMounted = (0, import_react10.useRef)(false);
-  const parsedArgs = import_core4.UseFormUtils.parseUseFormArguments(...args);
-  const { rememberKey, data: initialData } = parsedArgs;
-  const precognitionEndpoint = (0, import_react10.useRef)(parsedArgs.precognitionEndpoint);
-  const [defaults, setDefaults] = (0, import_react10.useState)(
-    typeof initialData === "function" ? (0, import_lodash_es.cloneDeep)(initialData()) : (0, import_lodash_es.cloneDeep)(initialData)
-  );
-  const cancelToken = (0, import_react10.useRef)(null);
-  const recentlySuccessfulTimeoutId = (0, import_react10.useRef)(void 0);
-  const excludeKeysRef = (0, import_react10.useRef)([]);
-  const [data, setData] = rememberKey ? useRemember(defaults, `${rememberKey}:data`, excludeKeysRef) : (0, import_react10.useState)(defaults);
-  const [errors, setErrors] = rememberKey ? useRemember({}, `${rememberKey}:errors`) : (0, import_react10.useState)({});
-  const [hasErrors, setHasErrors] = (0, import_react10.useState)(false);
-  const [processing, setProcessing] = (0, import_react10.useState)(false);
-  const [progress2, setProgress] = (0, import_react10.useState)(null);
-  const [wasSuccessful, setWasSuccessful] = (0, import_react10.useState)(false);
-  const [recentlySuccessful, setRecentlySuccessful] = (0, import_react10.useState)(false);
-  const transform = (0, import_react10.useRef)((data2) => data2);
-  const isDirty = (0, import_react10.useMemo)(() => !(0, import_lodash_es.isEqual)(data, defaults), [data, defaults]);
-  const validatorRef = (0, import_react10.useRef)(null);
-  const [validating, setValidating] = (0, import_react10.useState)(false);
-  const [touchedFields, setTouchedFields] = (0, import_react10.useState)([]);
-  const [validFields, setValidFields] = (0, import_react10.useState)([]);
-  const withAllErrors = (0, import_react10.useRef)(null);
-  (0, import_react10.useEffect)(() => {
+// src/useFormState.ts
+import {
+  UseFormUtils
+} from "@inertiajs/core";
+import {
+  createValidator,
+  resolveName,
+  toSimpleValidationErrors
+} from "laravel-precognition";
+import { cloneDeep, get as get2, has, isEqual, set } from "lodash-es";
+import { useCallback, useEffect as useEffect4, useMemo as useMemo4, useRef as useRef2, useState as useState3 } from "react";
+function useFormState(options) {
+  const { data: dataOption, useDataState, useErrorsState } = options;
+  const isDataFunction = typeof dataOption === "function";
+  const resolveData = () => isDataFunction ? dataOption() : dataOption;
+  const initialData = cloneDeep(resolveData());
+  const isMounted = useRef2(false);
+  const precognitionEndpointRef = useRef2(options.precognitionEndpoint ?? null);
+  const [defaults, setDefaultsState] = useState3(cloneDeep(initialData));
+  const [data, setData] = useDataState ? useDataState() : useState3(cloneDeep(initialData));
+  const [errors, setErrors] = useErrorsState ? useErrorsState() : useState3({});
+  const [hasErrors, setHasErrors] = useState3(false);
+  const [processing, setProcessing] = useState3(false);
+  const [progress2, setProgress] = useState3(null);
+  const [wasSuccessful, setWasSuccessful] = useState3(false);
+  const [recentlySuccessful, setRecentlySuccessful] = useState3(false);
+  const recentlySuccessfulTimeoutId = useRef2(void 0);
+  const transformRef = useRef2((data2) => data2);
+  const isDirty = useMemo4(() => !isEqual(data, defaults), [data, defaults]);
+  const defaultsCalledInOnSuccessRef = useRef2(false);
+  const validatorRef = useRef2(null);
+  const [validating, setValidating] = useState3(false);
+  const [touchedFields, setTouchedFields] = useState3([]);
+  const [validFields, setValidFields] = useState3([]);
+  const withAllErrorsRef = useRef2(null);
+  const withAllErrorsEnabled = () => withAllErrorsRef.current ?? config.get("form.withAllErrors");
+  const dataRef = useRef2(data);
+  useEffect4(() => {
+    dataRef.current = data;
+  });
+  useEffect4(() => {
     isMounted.current = true;
     return () => {
       isMounted.current = false;
     };
   }, []);
-  const setDefaultsCalledInOnSuccess = (0, import_react10.useRef)(false);
-  const submit = (0, import_react10.useCallback)(
-    (...args2) => {
-      const { method, url, options } = import_core4.UseFormUtils.parseSubmitArguments(args2, precognitionEndpoint.current);
-      setDefaultsCalledInOnSuccess.current = false;
-      const _options = {
-        ...options,
-        onCancelToken: (token) => {
-          cancelToken.current = token;
-          if (options.onCancelToken) {
-            return options.onCancelToken(token);
-          }
-        },
-        onBefore: (visit) => {
-          setWasSuccessful(false);
-          setRecentlySuccessful(false);
-          clearTimeout(recentlySuccessfulTimeoutId.current);
-          if (options.onBefore) {
-            return options.onBefore(visit);
-          }
-        },
-        onStart: (visit) => {
-          setProcessing(true);
-          if (options.onStart) {
-            return options.onStart(visit);
-          }
-        },
-        onProgress: (event) => {
-          setProgress(event || null);
-          if (options.onProgress) {
-            return options.onProgress(event);
-          }
-        },
-        onSuccess: async (page) => {
-          if (isMounted.current) {
-            setProcessing(false);
-            setProgress(null);
-            setErrors({});
-            setHasErrors(false);
-            setWasSuccessful(true);
-            setRecentlySuccessful(true);
-            recentlySuccessfulTimeoutId.current = setTimeout(() => {
-              if (isMounted.current) {
-                setRecentlySuccessful(false);
-              }
-            }, config.get("form.recentlySuccessfulDuration"));
-          }
-          const onSuccess = options.onSuccess ? await options.onSuccess(page) : null;
-          if (isMounted.current && !setDefaultsCalledInOnSuccess.current) {
-            setData((data2) => {
-              setDefaults((0, import_lodash_es.cloneDeep)(data2));
-              return data2;
-            });
-          }
-          return onSuccess;
-        },
-        onError: (errors2) => {
-          if (isMounted.current) {
-            setProcessing(false);
-            setProgress(null);
-            setErrors(errors2);
-            setHasErrors(Object.keys(errors2).length > 0);
-            validatorRef.current?.setErrors(errors2);
-          }
-          if (options.onError) {
-            return options.onError(errors2);
-          }
-        },
-        onCancel: () => {
-          if (isMounted.current) {
-            setProcessing(false);
-            setProgress(null);
-          }
-          if (options.onCancel) {
-            return options.onCancel();
-          }
-        },
-        onFinish: (visit) => {
-          if (isMounted.current) {
-            setProcessing(false);
-            setProgress(null);
-          }
-          cancelToken.current = null;
-          if (options.onFinish) {
-            return options.onFinish(visit);
-          }
-        }
-      };
-      const transformedData = transform.current(data);
-      if (method === "delete") {
-        import_core4.router.delete(url, { ..._options, data: transformedData });
-      } else {
-        import_core4.router[method](url, transformedData, _options);
-      }
-    },
-    [data, setErrors, transform]
-  );
-  const setDataFunction = (0, import_react10.useCallback)(
+  const setDataFunction = useCallback(
     (keyOrData, maybeValue) => {
       if (typeof keyOrData === "string") {
-        setData((data2) => (0, import_lodash_es.set)((0, import_lodash_es.cloneDeep)(data2), keyOrData, maybeValue));
+        setData((data2) => set(cloneDeep(data2), keyOrData, maybeValue));
       } else if (typeof keyOrData === "function") {
         setData((data2) => keyOrData(data2));
       } else {
@@ -469,47 +444,49 @@ function useForm(...args) {
     },
     [setData]
   );
-  const [dataAsDefaults, setDataAsDefaults] = (0, import_react10.useState)(false);
-  const dataRef = (0, import_react10.useRef)(data);
-  (0, import_react10.useEffect)(() => {
-    dataRef.current = data;
-  });
-  const setDefaultsFunction = (0, import_react10.useCallback)(
+  const setDefaultsFunction = useCallback(
     (fieldOrFields, maybeValue) => {
-      setDefaultsCalledInOnSuccess.current = true;
+      if (isDataFunction) {
+        throw new Error("You cannot call `defaults()` when using a function to define your form data.");
+      }
+      defaultsCalledInOnSuccessRef.current = true;
       let newDefaults = {};
       if (typeof fieldOrFields === "undefined") {
         newDefaults = { ...dataRef.current };
-        setDefaults(dataRef.current);
-        setDataAsDefaults(true);
+        setDefaultsState(dataRef.current);
       } else {
-        setDefaults((defaults2) => {
-          newDefaults = typeof fieldOrFields === "string" ? (0, import_lodash_es.set)((0, import_lodash_es.cloneDeep)(defaults2), fieldOrFields, maybeValue) : Object.assign((0, import_lodash_es.cloneDeep)(defaults2), fieldOrFields);
+        setDefaultsState((defaults2) => {
+          newDefaults = typeof fieldOrFields === "string" ? set(cloneDeep(defaults2), fieldOrFields, maybeValue) : Object.assign(cloneDeep(defaults2), fieldOrFields);
           return newDefaults;
         });
       }
       validatorRef.current?.defaults(newDefaults);
     },
-    [setDefaults]
+    [setDefaultsState]
   );
-  useIsomorphicLayoutEffect(() => {
-    if (!dataAsDefaults) {
-      return;
-    }
-    if (isDirty) {
-      setDefaults(data);
-    }
-    setDataAsDefaults(false);
-  }, [dataAsDefaults]);
-  const reset = (0, import_react10.useCallback)(
+  const reset = useCallback(
     (...fields) => {
+      const resolvedData = isDataFunction ? cloneDeep(resolveData()) : defaults;
+      const clonedData = cloneDeep(resolvedData);
       if (fields.length === 0) {
-        setData(defaults);
+        if (isDataFunction) {
+          setDefaultsState(clonedData);
+        }
+        setData(clonedData);
       } else {
+        if (isDataFunction) {
+          setDefaultsState((currentDefaults) => {
+            const newDefaults = cloneDeep(currentDefaults);
+            fields.filter((key) => has(clonedData, key)).forEach((key) => {
+              set(newDefaults, key, get2(clonedData, key));
+            });
+            return newDefaults;
+          });
+        }
         setData(
-          (data2) => fields.filter((key) => (0, import_lodash_es.has)(defaults, key)).reduce(
+          (data2) => fields.filter((key) => has(clonedData, key)).reduce(
             (carry, key) => {
-              return (0, import_lodash_es.set)(carry, key, (0, import_lodash_es.get)(defaults, key));
+              return set(carry, key, get2(clonedData, key));
             },
             { ...data2 }
           )
@@ -519,7 +496,7 @@ function useForm(...args) {
     },
     [setData, defaults]
   );
-  const setError = (0, import_react10.useCallback)(
+  const setError = useCallback(
     (fieldOrFields, maybeValue) => {
       setErrors((errors2) => {
         const newErrors = {
@@ -533,7 +510,7 @@ function useForm(...args) {
     },
     [setErrors, setHasErrors]
   );
-  const clearErrors = (0, import_react10.useCallback)(
+  const clearErrors = useCallback(
     (...fields) => {
       setErrors((errors2) => {
         const newErrors = Object.keys(errors2).reduce(
@@ -556,29 +533,48 @@ function useForm(...args) {
     },
     [setErrors, setHasErrors]
   );
-  const resetAndClearErrors = (0, import_react10.useCallback)(
+  const resetAndClearErrors = useCallback(
     (...fields) => {
       reset(...fields);
       clearErrors(...fields);
     },
     [reset, clearErrors]
   );
-  const createSubmitMethod = (method) => (url, options = {}) => {
-    submit(method, url, options);
-  };
-  const getMethod = (0, import_react10.useCallback)(createSubmitMethod("get"), [submit]);
-  const post = (0, import_react10.useCallback)(createSubmitMethod("post"), [submit]);
-  const put = (0, import_react10.useCallback)(createSubmitMethod("put"), [submit]);
-  const patch = (0, import_react10.useCallback)(createSubmitMethod("patch"), [submit]);
-  const deleteMethod = (0, import_react10.useCallback)(createSubmitMethod("delete"), [submit]);
-  const cancel = (0, import_react10.useCallback)(() => {
-    if (cancelToken.current) {
-      cancelToken.current.cancel();
-    }
-  }, []);
-  const transformFunction = (0, import_react10.useCallback)((callback) => {
-    transform.current = callback;
+  const markAsSuccessful = useCallback(() => {
+    clearErrors();
+    setWasSuccessful(true);
+    setRecentlySuccessful(true);
+    recentlySuccessfulTimeoutId.current = window.setTimeout(() => {
+      if (isMounted.current) {
+        setRecentlySuccessful(false);
+      }
+    }, config.get("form.recentlySuccessfulDuration"));
+  }, [clearErrors, setWasSuccessful, setRecentlySuccessful]);
+  const resetBeforeSubmit = useCallback(() => {
+    setWasSuccessful(false);
+    setRecentlySuccessful(false);
+    clearTimeout(recentlySuccessfulTimeoutId.current);
+  }, [setWasSuccessful, setRecentlySuccessful]);
+  const finishProcessing = useCallback(() => {
+    setProcessing(false);
+    setProgress(null);
+  }, [setProcessing, setProgress]);
+  const transformFunction = useCallback((callback) => {
+    transformRef.current = callback;
   }, []);
+  const tap = (value, callback) => {
+    callback(value);
+    return value;
+  };
+  const valid = useCallback(
+    (field) => validFields.includes(field),
+    [validFields]
+  );
+  const invalid = useCallback((field) => field in errors, [errors]);
+  const touched = useCallback(
+    (field) => typeof field === "string" ? touchedFields.includes(field) : touchedFields.length > 0,
+    [touchedFields]
+  );
   const form = {
     data,
     setData: setDataFunction,
@@ -594,32 +590,8 @@ function useForm(...args) {
     reset,
     setError,
     clearErrors,
-    resetAndClearErrors,
-    submit,
-    get: getMethod,
-    post,
-    put,
-    patch,
-    delete: deleteMethod,
-    cancel,
-    dontRemember: (...keys) => {
-      excludeKeysRef.current = keys;
-      return form;
-    }
-  };
-  const tap = (value, callback) => {
-    callback(value);
-    return value;
+    resetAndClearErrors
   };
-  const valid = (0, import_react10.useCallback)(
-    (field) => validFields.includes(field),
-    [validFields]
-  );
-  const invalid = (0, import_react10.useCallback)((field) => field in errors, [errors]);
-  const touched = (0, import_react10.useCallback)(
-    (field) => typeof field === "string" ? touchedFields.includes(field) : touchedFields.length > 0,
-    [touchedFields]
-  );
   const validate = (field, config3) => {
     if (typeof field === "object" && !("target" in field)) {
       config3 = field;
@@ -628,22 +600,24 @@ function useForm(...args) {
     if (field === void 0) {
       validatorRef.current.validate(config3);
     } else {
-      const fieldName = (0, import_laravel_precognition.resolveName)(field);
-      const currentData = dataRef.current;
-      const transformedData = transform.current(currentData);
-      validatorRef.current.validate(fieldName, (0, import_lodash_es.get)(transformedData, fieldName), config3);
+      const fieldName = resolveName(field);
+      const transformedData = transformRef.current(dataRef.current);
+      validatorRef.current.validate(fieldName, get2(transformedData, fieldName), config3);
     }
     return form;
   };
-  const withPrecognition = (...args2) => {
-    precognitionEndpoint.current = import_core4.UseFormUtils.createWayfinderCallback(...args2);
+  const withPrecognition = (...args) => {
+    precognitionEndpointRef.current = UseFormUtils.createWayfinderCallback(...args);
     if (!validatorRef.current) {
-      const validator = (0, import_laravel_precognition.createValidator)((client) => {
-        const { method, url } = precognitionEndpoint.current();
-        const currentData = dataRef.current;
-        const transformedData = transform.current(currentData);
-        return client[method](url, transformedData);
-      }, (0, import_lodash_es.cloneDeep)(defaults));
+      const validator = createValidator(
+        (client) => {
+          const { method, url } = precognitionEndpointRef.current();
+          const currentData = dataRef.current;
+          const transformedData = transformRef.current(currentData);
+          return client[method](url, transformedData);
+        },
+        cloneDeep(defaults)
+      );
       validatorRef.current = validator;
       validator.on("validatingChanged", () => {
         setValidating(validator.validating());
@@ -652,7 +626,7 @@ function useForm(...args) {
       }).on("touchedChanged", () => {
         setTouchedFields(validator.touched());
       }).on("errorsChanged", () => {
-        const validationErrors = withAllErrors.current ?? config.get("form.withAllErrors") ? validator.errors() : (0, import_laravel_precognition.toSimpleValidationErrors)(validator.errors());
+        const validationErrors = withAllErrorsEnabled() ? validator.errors() : toSimpleValidationErrors(validator.errors());
         setErrors(validationErrors);
         setHasErrors(Object.keys(validationErrors).length > 0);
         setValidFields(validator.valid());
@@ -675,29 +649,221 @@ function useForm(...args) {
         }
         return precognitiveForm;
       },
-      withAllErrors: () => tap(precognitiveForm, () => withAllErrors.current = true),
+      withAllErrors: () => tap(precognitiveForm, () => withAllErrorsRef.current = true),
       setValidationTimeout: (duration) => tap(precognitiveForm, () => validatorRef.current?.setTimeout(duration)),
       validateFiles: () => tap(precognitiveForm, () => validatorRef.current?.validateFiles()),
       validate,
       setErrors: (errors2) => tap(precognitiveForm, () => form.setError(errors2)),
       forgetError: (field) => tap(
         precognitiveForm,
-        () => form.clearErrors((0, import_laravel_precognition.resolveName)(field))
+        () => form.clearErrors(resolveName(field))
       )
     });
     return precognitiveForm;
   };
   form.withPrecognition = withPrecognition;
-  return precognitionEndpoint.current ? form.withPrecognition(precognitionEndpoint.current) : form;
+  if (precognitionEndpointRef.current) {
+    form.withPrecognition(precognitionEndpointRef.current);
+  }
+  return {
+    form,
+    setDefaultsState,
+    transformRef,
+    precognitionEndpointRef,
+    dataRef,
+    isMounted,
+    setProcessing,
+    setProgress,
+    markAsSuccessful,
+    clearErrors,
+    setError,
+    defaultsCalledInOnSuccessRef,
+    resetBeforeSubmit,
+    finishProcessing,
+    withAllErrors: {
+      enabled: withAllErrorsEnabled,
+      enable: () => {
+        withAllErrorsRef.current = true;
+      }
+    }
+  };
+}
+
+// src/useRemember.ts
+import { router as router4 } from "@inertiajs/core";
+import { useEffect as useEffect5, useState as useState4 } from "react";
+function useRemember(initialState, key, excludeKeysRef) {
+  const [state, setState] = useState4(() => {
+    const restored = router4.restore(key);
+    return restored !== void 0 ? restored : initialState;
+  });
+  useEffect5(() => {
+    const keys = excludeKeysRef?.current;
+    if (keys && keys.length > 0 && typeof state === "object" && state !== null) {
+      const filtered = { ...state };
+      keys.forEach((k) => delete filtered[k]);
+      router4.remember(filtered, key);
+    } else {
+      router4.remember(state, key);
+    }
+  }, [state, key]);
+  return [state, setState];
+}
+
+// src/useForm.ts
+function useForm(...args) {
+  const { rememberKey, data, precognitionEndpoint } = UseFormUtils2.parseUseFormArguments(...args);
+  const initialDefaults = typeof data === "function" ? cloneDeep2(data()) : cloneDeep2(data);
+  const cancelToken = useRef3(null);
+  const excludeKeysRef = useRef3([]);
+  const pendingOptimisticRef = useRef3(null);
+  const useDataState = rememberKey ? () => useRemember(initialDefaults, `${rememberKey}:data`, excludeKeysRef) : void 0;
+  const useErrorsState = rememberKey ? () => useRemember({}, `${rememberKey}:errors`) : void 0;
+  const {
+    form: baseForm,
+    setDefaultsState,
+    transformRef,
+    precognitionEndpointRef,
+    isMounted,
+    setProcessing,
+    setProgress,
+    markAsSuccessful,
+    clearErrors,
+    setError,
+    defaultsCalledInOnSuccessRef,
+    resetBeforeSubmit,
+    finishProcessing
+  } = useFormState({
+    data,
+    precognitionEndpoint,
+    useDataState,
+    useErrorsState
+  });
+  const [dataAsDefaults, setDataAsDefaults] = useState5(false);
+  const originalSetDefaults = baseForm.setDefaults;
+  baseForm.setDefaults = useCallback2(
+    (fieldOrFields, maybeValue) => {
+      if (typeof fieldOrFields === "undefined") {
+        setDataAsDefaults(true);
+      }
+      return originalSetDefaults(fieldOrFields, maybeValue);
+    },
+    [originalSetDefaults]
+  );
+  useIsomorphicLayoutEffect(() => {
+    if (!dataAsDefaults) {
+      return;
+    }
+    if (baseForm.isDirty) {
+      setDefaultsState(baseForm.data);
+    }
+    setDataAsDefaults(false);
+  }, [dataAsDefaults]);
+  const submit = useCallback2(
+    (...args2) => {
+      const { method, url, options } = UseFormUtils2.parseSubmitArguments(args2, precognitionEndpointRef.current);
+      defaultsCalledInOnSuccessRef.current = false;
+      const _options = {
+        ...options,
+        onCancelToken: (token) => {
+          cancelToken.current = token;
+          return options.onCancelToken?.(token);
+        },
+        onBefore: (visit) => {
+          resetBeforeSubmit();
+          return options.onBefore?.(visit);
+        },
+        onStart: (visit) => {
+          setProcessing(true);
+          return options.onStart?.(visit);
+        },
+        onProgress: (event) => {
+          setProgress(event || null);
+          return options.onProgress?.(event);
+        },
+        onSuccess: async (page) => {
+          if (isMounted.current) {
+            markAsSuccessful();
+          }
+          const onSuccess = options.onSuccess ? await options.onSuccess(page) : null;
+          if (isMounted.current && !defaultsCalledInOnSuccessRef.current) {
+            baseForm.setData((data2) => {
+              setDefaultsState(cloneDeep2(data2));
+              return data2;
+            });
+          }
+          return onSuccess;
+        },
+        onError: (errors) => {
+          if (isMounted.current) {
+            clearErrors();
+            setError(errors);
+          }
+          return options.onError?.(errors);
+        },
+        onCancel: () => {
+          return options.onCancel?.();
+        },
+        onFinish: (visit) => {
+          if (isMounted.current) {
+            finishProcessing();
+          }
+          cancelToken.current = null;
+          return options.onFinish?.(visit);
+        }
+      };
+      _options.optimistic = _options.optimistic ?? pendingOptimisticRef.current ?? void 0;
+      pendingOptimisticRef.current = null;
+      const transformedData = transformRef.current(baseForm.data);
+      if (method === "delete") {
+        router5.delete(url, { ..._options, data: transformedData });
+      } else {
+        router5[method](url, transformedData, _options);
+      }
+    },
+    [baseForm.data, clearErrors, setError, transformRef]
+  );
+  const cancel = useCallback2(() => {
+    if (cancelToken.current) {
+      cancelToken.current.cancel();
+    }
+  }, []);
+  const createSubmitMethod = (method) => (url, options = {}) => {
+    submit(method, url, options);
+  };
+  Object.assign(baseForm, {
+    submit,
+    get: createSubmitMethod("get"),
+    post: createSubmitMethod("post"),
+    put: createSubmitMethod("put"),
+    patch: createSubmitMethod("patch"),
+    delete: createSubmitMethod("delete"),
+    cancel,
+    dontRemember: (...keys) => {
+      excludeKeysRef.current = keys;
+      return form;
+    },
+    optimistic: (callback) => {
+      pendingOptimisticRef.current = callback;
+      return form;
+    }
+  });
+  const form = baseForm;
+  const originalWithPrecognition = baseForm.withPrecognition;
+  form.withPrecognition = (...args2) => {
+    originalWithPrecognition(...args2);
+    return form;
+  };
+  return precognitionEndpointRef.current ? form : form;
 }
 
 // src/Form.ts
 var deferStateUpdate = (callback) => {
-  typeof import_react12.default.startTransition === "function" ? import_react12.default.startTransition(callback) : setTimeout(callback, 0);
+  typeof React.startTransition === "function" ? React.startTransition(callback) : setTimeout(callback, 0);
 };
 var noop = () => void 0;
-var FormContext = (0, import_react12.createContext)(void 0);
-var Form = (0, import_react12.forwardRef)(
+var FormContext = createContext4(void 0);
+var Form = forwardRef(
   ({
     action = "",
     method = "get",
@@ -706,6 +872,7 @@ var Form = (0, import_react12.forwardRef)(
     errorBag = null,
     showProgress = true,
     transform = (data) => data,
+    optimistic,
     options = {},
     onStart = noop,
     onProgress = noop,
@@ -724,6 +891,8 @@ var Form = (0, import_react12.forwardRef)(
     validateFiles = false,
     validationTimeout = 1500,
     withAllErrors = null,
+    component = null,
+    instant = false,
     children,
     ...props
   }, ref) => {
@@ -738,39 +907,48 @@ var Form = (0, import_react12.forwardRef)(
     if (validateFiles) {
       form.validateFiles();
     }
-    if (withAllErrors ?? import_core5.config.get("form.withAllErrors")) {
+    if (withAllErrors ?? config2.get("form.withAllErrors")) {
       form.withAllErrors();
     }
     form.transform(getTransformedData);
-    const formElement = (0, import_react12.useRef)(void 0);
-    const resolvedMethod = (0, import_react12.useMemo)(() => {
-      return (0, import_core5.isUrlMethodPair)(action) ? action.method : method.toLowerCase();
+    const formElement = useRef4(void 0);
+    const resolvedMethod = useMemo5(() => {
+      return isUrlMethodPair(action) ? action.method : method.toLowerCase();
     }, [action, method]);
-    const [isDirty, setIsDirty] = (0, import_react12.useState)(false);
-    const defaultData = (0, import_react12.useRef)(new FormData());
+    const resolvedComponent = useMemo5(() => {
+      if (component) {
+        return component;
+      }
+      if (instant && isUrlMethodPair(action)) {
+        return resolveUrlMethodPairComponent(action);
+      }
+      return null;
+    }, [component, instant, action]);
+    const [isDirty, setIsDirty] = useState6(false);
+    const defaultData = useRef4(new FormData());
     const getFormData = (submitter) => new FormData(formElement.current, submitter);
-    const getData = (submitter) => (0, import_core5.formDataToObject)(getFormData(submitter));
+    const getData = (submitter) => formDataToObject(getFormData(submitter));
     const getUrlAndData = (submitter) => {
-      return (0, import_core5.mergeDataIntoQueryString)(
+      return mergeDataIntoQueryString(
         resolvedMethod,
-        (0, import_core5.isUrlMethodPair)(action) ? action.url : action,
+        isUrlMethodPair(action) ? action.url : action,
         getData(submitter),
         queryStringArrayFormat
       );
     };
     const updateDirtyState = (event) => {
-      if (event.type === "reset" && event.detail?.[import_core5.FormComponentResetSymbol]) {
+      if (event.type === "reset" && event.detail?.[FormComponentResetSymbol]) {
         event.preventDefault();
       }
       deferStateUpdate(
-        () => setIsDirty(event.type === "reset" ? false : !(0, import_lodash_es2.isEqual)(getData(), (0, import_core5.formDataToObject)(defaultData.current)))
+        () => setIsDirty(event.type === "reset" ? false : !isEqual2(getData(), formDataToObject(defaultData.current)))
       );
     };
     const clearErrors = (...names) => {
       form.clearErrors(...names);
       return form;
     };
-    (0, import_react12.useEffect)(() => {
+    useEffect6(() => {
       defaultData.current = getFormData();
       form.setDefaults(getData());
       const formEvents = ["input", "change", "reset"];
@@ -779,10 +957,10 @@ var Form = (0, import_react12.forwardRef)(
         formEvents.forEach((e) => formElement.current?.removeEventListener(e, updateDirtyState));
       };
     }, []);
-    (0, import_react12.useEffect)(() => {
+    useEffect6(() => {
       form.setValidationTimeout(validationTimeout);
     }, [validationTimeout]);
-    (0, import_react12.useEffect)(() => {
+    useEffect6(() => {
       if (validateFiles) {
         form.validateFiles();
       } else {
@@ -791,7 +969,7 @@ var Form = (0, import_react12.forwardRef)(
     }, [validateFiles]);
     const reset = (...fields) => {
       if (formElement.current) {
-        (0, import_core5.resetFormFields)(formElement.current, defaultData.current, fields);
+        resetFormFields(formElement.current, defaultData.current, fields);
       }
       form.reset(...fields);
     };
@@ -822,6 +1000,8 @@ var Form = (0, import_react12.forwardRef)(
         errorBag,
         showProgress,
         invalidateCacheTags,
+        component: resolvedComponent,
+        optimistic: optimistic ? (pageProps) => optimistic(pageProps, data) : void 0,
         onCancelToken,
         onBefore,
         onStart,
@@ -874,46 +1054,43 @@ var Form = (0, import_react12.forwardRef)(
       validating: form.validating,
       valid: form.valid,
       invalid: form.invalid,
-      validate: (field, config3) => form.validate(...import_core5.UseFormUtils.mergeHeadersForValidation(field, config3, headers)),
+      validate: (field, config3) => form.validate(...UseFormUtils3.mergeHeadersForValidation(field, config3, headers)),
       touch: form.touch,
       touched: form.touched
     };
-    (0, import_react12.useImperativeHandle)(ref, () => exposed, [form, isDirty, submit]);
-    const formNode = (0, import_react12.createElement)(
+    useImperativeHandle(ref, () => exposed, [form, isDirty, submit]);
+    const formNode = createElement3(
       "form",
       {
         ...props,
         ref: formElement,
-        action: (0, import_core5.isUrlMethodPair)(action) ? action.url : action,
+        action: isUrlMethodPair(action) ? action.url : action,
         method: resolvedMethod,
         onSubmit: (event) => {
           event.preventDefault();
           submit(event.nativeEvent.submitter);
         },
-        // React 19 supports passing a boolean to the `inert` attribute, but shows
-        // a warning when receiving a string. Earlier versions require the string 'true'.
-        // See: https://github.com/inertiajs/inertia/pull/2536
-        inert: disableWhileProcessing && form.processing && (isReact19 ? true : "true")
+        inert: disableWhileProcessing && form.processing
       },
       typeof children === "function" ? children(exposed) : children
     );
-    return (0, import_react12.createElement)(FormContext.Provider, { value: exposed }, formNode);
+    return createElement3(FormContext.Provider, { value: exposed }, formNode);
   }
 );
 Form.displayName = "InertiaForm";
 function useFormContext() {
-  return (0, import_react12.useContext)(FormContext);
+  return use2(FormContext);
 }
 var Form_default = Form;
 
 // src/Head.ts
-var import_lodash_es3 = require("lodash-es");
-var import_react14 = __toESM(require("react"), 1);
+import { escape } from "lodash-es";
+import React2, { use as use3, useEffect as useEffect7, useMemo as useMemo6 } from "react";
 var Head = function({ children, title }) {
-  const headManager = (0, import_react14.useContext)(HeadContext_default);
-  const provider = (0, import_react14.useMemo)(() => headManager.createProvider(), [headManager]);
+  const headManager = use3(HeadContext_default);
+  const provider = useMemo6(() => headManager.createProvider(), [headManager]);
   const isServer = typeof window === "undefined";
-  (0, import_react14.useEffect)(() => {
+  useEffect7(() => {
     provider.reconnect();
     provider.update(renderNodes(children));
     return () => {
@@ -948,7 +1125,7 @@ var Head = function({ children, title }) {
       if (value === "") {
         return carry + ` ${name}`;
       }
-      return carry + ` ${name}="${(0, import_lodash_es3.escape)(value)}"`;
+      return carry + ` ${name}="${escape(value)}"`;
     }, "");
     return `<${String(node.type)}${attrs}>`;
   }
@@ -976,17 +1153,17 @@ var Head = function({ children, title }) {
     return html;
   }
   function ensureNodeHasInertiaProp(node) {
-    return import_react14.default.cloneElement(node, {
-      [provider.preferredAttribute()]: node.props["head-key"] !== void 0 ? node.props["head-key"] : ""
+    return React2.cloneElement(node, {
+      "data-inertia": node.props["head-key"] !== void 0 ? node.props["head-key"] : ""
     });
   }
   function renderNode(node) {
     return renderTag(ensureNodeHasInertiaProp(node));
   }
   function renderNodes(nodes) {
-    const elements = import_react14.default.Children.toArray(nodes).filter((node) => node).map((node) => renderNode(node));
+    const elements = React2.Children.toArray(nodes).filter((node) => node).map((node) => renderNode(node));
     if (title && !elements.find((tag) => tag.startsWith("<title"))) {
-      elements.push(`<title ${provider.preferredAttribute()}>${title}</title>`);
+      elements.push(`<title data-inertia="">${title}</title>`);
     }
     return elements;
   }
@@ -998,8 +1175,20 @@ var Head = function({ children, title }) {
 var Head_default = Head;
 
 // src/InfiniteScroll.ts
-var import_core6 = require("@inertiajs/core");
-var import_react15 = __toESM(require("react"), 1);
+import {
+  getScrollableParent,
+  useInfiniteScroll
+} from "@inertiajs/core";
+import React3, {
+  createElement as createElement4,
+  forwardRef as forwardRef2,
+  useCallback as useCallback3,
+  useEffect as useEffect8,
+  useImperativeHandle as useImperativeHandle2,
+  useMemo as useMemo7,
+  useRef as useRef5,
+  useState as useState7
+} from "react";
 var resolveHTMLElement = (value, fallback) => {
   if (!value) {
     return fallback;
@@ -1018,7 +1207,7 @@ var renderSlot = (slotContent, slotProps, fallback = null) => {
   }
   return typeof slotContent === "function" ? slotContent(slotProps) : slotContent;
 };
-var InfiniteScroll = (0, import_react15.forwardRef)(
+var InfiniteScroll = forwardRef2(
   ({
     data,
     buffer = 0,
@@ -1035,55 +1224,58 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
     previous,
     next,
     loading,
+    params = {},
     onlyNext = false,
     onlyPrevious = false,
     ...props
   }, ref) => {
-    const [startElementFromRef, setStartElementFromRef] = (0, import_react15.useState)(null);
-    const startElementRef = (0, import_react15.useCallback)((node) => setStartElementFromRef(node), []);
-    const [endElementFromRef, setEndElementFromRef] = (0, import_react15.useState)(null);
-    const endElementRef = (0, import_react15.useCallback)((node) => setEndElementFromRef(node), []);
-    const [itemsElementFromRef, setItemsElementFromRef] = (0, import_react15.useState)(null);
-    const itemsElementRef = (0, import_react15.useCallback)((node) => setItemsElementFromRef(node), []);
-    const [loadingPrevious, setLoadingPrevious] = (0, import_react15.useState)(false);
-    const [loadingNext, setLoadingNext] = (0, import_react15.useState)(false);
-    const [requestCount, setRequestCount] = (0, import_react15.useState)(0);
-    const [hasPreviousPage, setHasPreviousPage] = (0, import_react15.useState)(false);
-    const [hasNextPage, setHasNextPage] = (0, import_react15.useState)(false);
-    const [resolvedStartElement, setResolvedStartElement] = (0, import_react15.useState)(null);
-    const [resolvedEndElement, setResolvedEndElement] = (0, import_react15.useState)(null);
-    const [resolvedItemsElement, setResolvedItemsElement] = (0, import_react15.useState)(null);
-    (0, import_react15.useEffect)(() => {
+    const [startElementFromRef, setStartElementFromRef] = useState7(null);
+    const startElementRef = useCallback3((node) => setStartElementFromRef(node), []);
+    const [endElementFromRef, setEndElementFromRef] = useState7(null);
+    const endElementRef = useCallback3((node) => setEndElementFromRef(node), []);
+    const [itemsElementFromRef, setItemsElementFromRef] = useState7(null);
+    const itemsElementRef = useCallback3((node) => setItemsElementFromRef(node), []);
+    const [loadingPrevious, setLoadingPrevious] = useState7(false);
+    const [loadingNext, setLoadingNext] = useState7(false);
+    const [requestCount, setRequestCount] = useState7(0);
+    const [hasPreviousPage, setHasPreviousPage] = useState7(false);
+    const [hasNextPage, setHasNextPage] = useState7(false);
+    const [resolvedStartElement, setResolvedStartElement] = useState7(null);
+    const [resolvedEndElement, setResolvedEndElement] = useState7(null);
+    const [resolvedItemsElement, setResolvedItemsElement] = useState7(null);
+    useEffect8(() => {
       const element = startElement ? resolveHTMLElement(startElement, startElementFromRef) : startElementFromRef;
       setResolvedStartElement(element);
     }, [startElement, startElementFromRef]);
-    (0, import_react15.useEffect)(() => {
+    useEffect8(() => {
       const element = endElement ? resolveHTMLElement(endElement, endElementFromRef) : endElementFromRef;
       setResolvedEndElement(element);
     }, [endElement, endElementFromRef]);
-    (0, import_react15.useEffect)(() => {
+    useEffect8(() => {
       const element = itemsElement ? resolveHTMLElement(itemsElement, itemsElementFromRef) : itemsElementFromRef;
       setResolvedItemsElement(element);
     }, [itemsElement, itemsElementFromRef]);
-    const scrollableParent = (0, import_react15.useMemo)(() => (0, import_core6.getScrollableParent)(resolvedItemsElement), [resolvedItemsElement]);
-    const callbackPropsRef = (0, import_react15.useRef)({
+    const scrollableParent = useMemo7(() => getScrollableParent(resolvedItemsElement), [resolvedItemsElement]);
+    const callbackPropsRef = useRef5({
       buffer,
       onlyNext,
       onlyPrevious,
       reverse,
-      preserveUrl
+      preserveUrl,
+      params
     });
     callbackPropsRef.current = {
       buffer,
       onlyNext,
       onlyPrevious,
       reverse,
-      preserveUrl
+      preserveUrl,
+      params
     };
-    const [infiniteScroll, setInfiniteScroll] = (0, import_react15.useState)(null);
-    const dataManager = (0, import_react15.useMemo)(() => infiniteScroll?.dataManager, [infiniteScroll]);
-    const elementManager = (0, import_react15.useMemo)(() => infiniteScroll?.elementManager, [infiniteScroll]);
-    const scrollToBottom = (0, import_react15.useCallback)(() => {
+    const [infiniteScroll, setInfiniteScroll] = useState7(null);
+    const dataManager = useMemo7(() => infiniteScroll?.dataManager, [infiniteScroll]);
+    const elementManager = useMemo7(() => infiniteScroll?.elementManager, [infiniteScroll]);
+    const scrollToBottom = useCallback3(() => {
       if (scrollableParent) {
         scrollableParent.scrollTo({
           top: scrollableParent.scrollHeight,
@@ -1096,7 +1288,7 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
         });
       }
     }, [scrollableParent]);
-    (0, import_react15.useEffect)(() => {
+    useEffect8(() => {
       if (!resolvedItemsElement) {
         return;
       }
@@ -1105,13 +1297,14 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
         setHasPreviousPage(infiniteScrollInstance.dataManager.hasPrevious());
         setHasNextPage(infiniteScrollInstance.dataManager.hasNext());
       }
-      const infiniteScrollInstance = (0, import_core6.useInfiniteScroll)({
+      const infiniteScrollInstance = useInfiniteScroll({
         // Data
         getPropName: () => data,
         inReverseMode: () => callbackPropsRef.current.reverse,
         shouldFetchNext: () => !callbackPropsRef.current.onlyPrevious,
         shouldFetchPrevious: () => !callbackPropsRef.current.onlyNext,
         shouldPreserveUrl: () => callbackPropsRef.current.preserveUrl,
+        getReloadOptions: () => callbackPropsRef.current.params,
         // Elements
         getTriggerMargin: () => callbackPropsRef.current.buffer,
         getStartElement: () => resolvedStartElement,
@@ -1144,21 +1337,21 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
         setInfiniteScroll(null);
       };
     }, [data, resolvedItemsElement, resolvedStartElement, resolvedEndElement, scrollableParent]);
-    const manualMode = (0, import_react15.useMemo)(
+    const manualMode = useMemo7(
       () => manual || manualAfter > 0 && requestCount >= manualAfter,
       [manual, manualAfter, requestCount]
     );
-    const autoLoad = (0, import_react15.useMemo)(() => !manualMode, [manualMode]);
-    (0, import_react15.useEffect)(() => {
+    const autoLoad = useMemo7(() => !manualMode, [manualMode]);
+    useEffect8(() => {
       autoLoad ? elementManager?.enableTriggers() : elementManager?.disableTriggers();
     }, [autoLoad, onlyNext, onlyPrevious, resolvedStartElement, resolvedEndElement]);
-    (0, import_react15.useEffect)(() => {
+    useEffect8(() => {
       const shouldAutoScroll = autoScroll !== void 0 ? autoScroll : reverse;
       if (shouldAutoScroll) {
         scrollToBottom();
       }
     }, [scrollableParent]);
-    (0, import_react15.useImperativeHandle)(
+    useImperativeHandle2(
       ref,
       () => ({
         fetchNext: dataManager?.fetchNext || (() => {
@@ -1204,7 +1397,7 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
     const renderElements = [];
     if (!startElement) {
       renderElements.push(
-        (0, import_react15.createElement)(
+        createElement4(
           "div",
           { ref: startElementRef },
           // Render previous slot or fallback to loading indicator
@@ -1213,7 +1406,7 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
       );
     }
     renderElements.push(
-      (0, import_react15.createElement)(
+      createElement4(
         as,
         { ...props, ref: itemsElementRef },
         typeof children === "function" ? children(exposedSlot) : children
@@ -1221,7 +1414,7 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
     );
     if (!endElement) {
       renderElements.push(
-        (0, import_react15.createElement)(
+        createElement4(
           "div",
           { ref: endElementRef },
           // Render next slot or fallback to loading indicator
@@ -1229,17 +1422,24 @@ var InfiniteScroll = (0, import_react15.forwardRef)(
         )
       );
     }
-    return (0, import_react15.createElement)(import_react15.default.Fragment, {}, ...reverse ? [...renderElements].reverse() : renderElements);
+    return createElement4(React3.Fragment, {}, ...reverse ? [...renderElements].reverse() : renderElements);
   }
 );
 InfiniteScroll.displayName = "InertiaInfiniteScroll";
 var InfiniteScroll_default = InfiniteScroll;
 
 // src/Link.ts
-var import_core7 = require("@inertiajs/core");
-var import_react16 = require("react");
+import {
+  isUrlMethodPair as isUrlMethodPair2,
+  mergeDataIntoQueryString as mergeDataIntoQueryString2,
+  resolveUrlMethodPairComponent as resolveUrlMethodPairComponent2,
+  router as router6,
+  shouldIntercept,
+  shouldNavigate
+} from "@inertiajs/core";
+import { createElement as createElement5, forwardRef as forwardRef3, useEffect as useEffect9, useMemo as useMemo8, useRef as useRef6, useState as useState8 } from "react";
 var noop2 = () => void 0;
-var Link = (0, import_react16.forwardRef)(
+var Link = forwardRef3(
   ({
     children,
     as = "a",
@@ -1270,26 +1470,38 @@ var Link = (0, import_react16.forwardRef)(
     cacheFor = 0,
     cacheTags = [],
     viewTransition = false,
+    component = null,
+    instant = false,
+    pageProps = null,
     ...props
   }, ref) => {
-    const [inFlightCount, setInFlightCount] = (0, import_react16.useState)(0);
-    const hoverTimeout = (0, import_react16.useRef)(void 0);
-    const _method = (0, import_react16.useMemo)(() => {
-      return (0, import_core7.isUrlMethodPair)(href) ? href.method : method.toLowerCase();
+    const [inFlightCount, setInFlightCount] = useState8(0);
+    const hoverTimeout = useRef6(void 0);
+    const _method = useMemo8(() => {
+      return isUrlMethodPair2(href) ? href.method : method.toLowerCase();
     }, [href, method]);
-    const _as = (0, import_react16.useMemo)(() => {
+    const resolvedComponent = useMemo8(() => {
+      if (component) {
+        return component;
+      }
+      if (instant && isUrlMethodPair2(href)) {
+        return resolveUrlMethodPairComponent2(href);
+      }
+      return null;
+    }, [component, instant, href]);
+    const _as = useMemo8(() => {
       if (typeof as !== "string" || as.toLowerCase() !== "a") {
         return as;
       }
       return _method !== "get" ? "button" : as.toLowerCase();
     }, [as, _method]);
-    const mergeDataArray = (0, import_react16.useMemo)(
-      () => (0, import_core7.mergeDataIntoQueryString)(_method, (0, import_core7.isUrlMethodPair)(href) ? href.url : href, data, queryStringArrayFormat),
+    const mergeDataArray = useMemo8(
+      () => mergeDataIntoQueryString2(_method, isUrlMethodPair2(href) ? href.url : href, data, queryStringArrayFormat),
       [href, _method, data, queryStringArrayFormat]
     );
-    const url = (0, import_react16.useMemo)(() => mergeDataArray[0], [mergeDataArray]);
-    const _data = (0, import_react16.useMemo)(() => mergeDataArray[1], [mergeDataArray]);
-    const baseParams = (0, import_react16.useMemo)(
+    const url = useMemo8(() => mergeDataArray[0], [mergeDataArray]);
+    const _data = useMemo8(() => mergeDataArray[1], [mergeDataArray]);
+    const baseParams = useMemo8(
       () => ({
         data: _data,
         method: _method,
@@ -1300,11 +1512,26 @@ var Link = (0, import_react16.forwardRef)(
         only,
         except,
         headers,
-        async
+        async,
+        component: resolvedComponent,
+        pageProps
       }),
-      [_data, _method, preserveScroll, preserveState, preserveUrl, replace, only, except, headers, async]
+      [
+        _data,
+        _method,
+        preserveScroll,
+        preserveState,
+        preserveUrl,
+        replace,
+        only,
+        except,
+        headers,
+        async,
+        resolvedComponent,
+        pageProps
+      ]
     );
-    const visitParams = (0, import_react16.useMemo)(
+    const visitParams = useMemo8(
       () => ({
         ...baseParams,
         viewTransition,
@@ -1336,7 +1563,7 @@ var Link = (0, import_react16.forwardRef)(
         onError
       ]
     );
-    const prefetchModes = (0, import_react16.useMemo)(
+    const prefetchModes = useMemo8(
       () => {
         if (prefetch === true) {
           return ["hover"];
@@ -1351,7 +1578,7 @@ var Link = (0, import_react16.forwardRef)(
       },
       Array.isArray(prefetch) ? prefetch : [prefetch]
     );
-    const cacheForValue = (0, import_react16.useMemo)(() => {
+    const cacheForValue = useMemo8(() => {
       if (cacheFor !== 0) {
         return cacheFor;
       }
@@ -1360,9 +1587,9 @@ var Link = (0, import_react16.forwardRef)(
       }
       return config.get("prefetch.cacheFor");
     }, [cacheFor, prefetchModes]);
-    const doPrefetch = (0, import_react16.useMemo)(() => {
+    const doPrefetch = useMemo8(() => {
       return () => {
-        import_core7.router.prefetch(
+        router6.prefetch(
           url,
           {
             ...baseParams,
@@ -1373,12 +1600,12 @@ var Link = (0, import_react16.forwardRef)(
         );
       };
     }, [url, baseParams, onPrefetching, onPrefetched, cacheForValue, cacheTags]);
-    (0, import_react16.useEffect)(() => {
+    useEffect9(() => {
       return () => {
         clearTimeout(hoverTimeout.current);
       };
     }, []);
-    (0, import_react16.useEffect)(() => {
+    useEffect9(() => {
       if (prefetchModes.includes("mount")) {
         setTimeout(() => doPrefetch());
       }
@@ -1386,9 +1613,9 @@ var Link = (0, import_react16.forwardRef)(
     const regularEvents = {
       onClick: (event) => {
         onClick(event);
-        if ((0, import_core7.shouldIntercept)(event)) {
+        if (shouldIntercept(event)) {
           event.preventDefault();
-          import_core7.router.visit(url, visitParams);
+          router6.visit(url, visitParams);
         }
       }
     };
@@ -1405,37 +1632,37 @@ var Link = (0, import_react16.forwardRef)(
     };
     const prefetchClickEvents = {
       onMouseDown: (event) => {
-        if ((0, import_core7.shouldIntercept)(event)) {
+        if (shouldIntercept(event)) {
           event.preventDefault();
           doPrefetch();
         }
       },
       onKeyDown: (event) => {
-        if ((0, import_core7.shouldNavigate)(event)) {
+        if (shouldNavigate(event)) {
           event.preventDefault();
           doPrefetch();
         }
       },
       onMouseUp: (event) => {
-        if ((0, import_core7.shouldIntercept)(event)) {
+        if (shouldIntercept(event)) {
           event.preventDefault();
-          import_core7.router.visit(url, visitParams);
+          router6.visit(url, visitParams);
         }
       },
       onKeyUp: (event) => {
-        if ((0, import_core7.shouldNavigate)(event)) {
+        if (shouldNavigate(event)) {
           event.preventDefault();
-          import_core7.router.visit(url, visitParams);
+          router6.visit(url, visitParams);
         }
       },
       onClick: (event) => {
         onClick(event);
-        if ((0, import_core7.shouldIntercept)(event)) {
+        if (shouldIntercept(event)) {
           event.preventDefault();
         }
       }
     };
-    const elProps = (0, import_react16.useMemo)(() => {
+    const elProps = useMemo8(() => {
       if (_as === "button") {
         return { type: "button" };
       }
@@ -1444,7 +1671,7 @@ var Link = (0, import_react16.forwardRef)(
       }
       return {};
     }, [_as, url]);
-    return (0, import_react16.createElement)(
+    return createElement5(
       _as,
       {
         ...props,
@@ -1468,20 +1695,223 @@ var Link = (0, import_react16.forwardRef)(
 Link.displayName = "InertiaLink";
 var Link_default = Link;
 
+// src/useHttp.ts
+import {
+  hasFiles,
+  http,
+  HttpCancelledError,
+  HttpResponseError,
+  mergeDataIntoQueryString as mergeDataIntoQueryString3,
+  objectToFormData,
+  UseFormUtils as UseFormUtils4
+} from "@inertiajs/core";
+import { toSimpleValidationErrors as toSimpleValidationErrors2 } from "laravel-precognition";
+import { cloneDeep as cloneDeep3 } from "lodash-es";
+import { useCallback as useCallback4, useRef as useRef7, useState as useState9 } from "react";
+function useHttp(...args) {
+  const { rememberKey, data, precognitionEndpoint } = UseFormUtils4.parseUseFormArguments(...args);
+  const initialDefaults = typeof data === "function" ? cloneDeep3(data()) : cloneDeep3(data);
+  const abortController = useRef7(null);
+  const excludeKeysRef = useRef7([]);
+  const pendingOptimisticRef = useRef7(null);
+  const [response, setResponse] = useState9(null);
+  const useDataState = rememberKey ? () => useRemember(initialDefaults, `${rememberKey}:data`, excludeKeysRef) : void 0;
+  const useErrorsState = rememberKey ? () => useRemember({}, `${rememberKey}:errors`) : void 0;
+  const {
+    form: baseForm,
+    setDefaultsState,
+    transformRef,
+    dataRef,
+    precognitionEndpointRef,
+    isMounted,
+    setProcessing,
+    setProgress,
+    markAsSuccessful,
+    clearErrors,
+    setError,
+    defaultsCalledInOnSuccessRef,
+    resetBeforeSubmit,
+    finishProcessing,
+    withAllErrors
+  } = useFormState({
+    data,
+    precognitionEndpoint,
+    useDataState,
+    useErrorsState
+  });
+  const submit = useCallback4(
+    async (method, url, options) => {
+      const onBefore = options.onBefore?.();
+      if (onBefore === false) {
+        return Promise.reject(new Error("Request cancelled by onBefore"));
+      }
+      defaultsCalledInOnSuccessRef.current = false;
+      if (isMounted.current) {
+        resetBeforeSubmit();
+      }
+      abortController.current = new AbortController();
+      const cancelToken = {
+        cancel: () => abortController.current?.abort()
+      };
+      options.onCancelToken?.(cancelToken);
+      options.optimistic = options.optimistic ?? pendingOptimisticRef.current ?? void 0;
+      pendingOptimisticRef.current = null;
+      let snapshot;
+      if (options.optimistic) {
+        snapshot = cloneDeep3(dataRef.current);
+        const optimisticData = options.optimistic(cloneDeep3(snapshot));
+        baseForm.setData((current) => ({ ...current, ...optimisticData }));
+      }
+      if (isMounted.current) {
+        setProcessing(true);
+      }
+      options.onStart?.();
+      const transformedData = transformRef.current(dataRef.current);
+      const useFormData = hasFiles(transformedData);
+      let requestUrl = url;
+      let requestData;
+      let contentType;
+      if (method === "get") {
+        const [urlWithParams] = mergeDataIntoQueryString3(
+          method,
+          url,
+          transformedData
+        );
+        requestUrl = urlWithParams;
+      } else {
+        if (useFormData) {
+          requestData = objectToFormData(transformedData);
+        } else {
+          requestData = JSON.stringify(transformedData);
+          contentType = "application/json";
+        }
+      }
+      try {
+        const httpResponse = await http.getClient().request({
+          method,
+          url: requestUrl,
+          data: requestData,
+          headers: {
+            Accept: "application/json",
+            ...contentType ? { "Content-Type": contentType } : {},
+            ...options.headers
+          },
+          signal: abortController.current.signal,
+          onUploadProgress: (event) => {
+            if (isMounted.current) {
+              setProgress(event);
+            }
+            options.onProgress?.(event);
+          }
+        });
+        const responseData = JSON.parse(httpResponse.data);
+        if (httpResponse.status >= 200 && httpResponse.status < 300) {
+          if (isMounted.current) {
+            markAsSuccessful();
+            setResponse(responseData);
+          }
+          options.onSuccess?.(responseData);
+          if (isMounted.current && !defaultsCalledInOnSuccessRef.current) {
+            baseForm.setData((data2) => {
+              setDefaultsState(cloneDeep3(data2));
+              return data2;
+            });
+          }
+          return responseData;
+        }
+        throw new HttpResponseError(`Request failed with status ${httpResponse.status}`, httpResponse);
+      } catch (error) {
+        if (snapshot && isMounted.current) {
+          baseForm.setData(snapshot);
+        }
+        if (error instanceof HttpResponseError) {
+          if (error.response.status === 422) {
+            const responseData = JSON.parse(error.response.data);
+            const validationErrors = responseData.errors || {};
+            const processedErrors = withAllErrors.enabled() ? validationErrors : toSimpleValidationErrors2(validationErrors);
+            if (isMounted.current) {
+              clearErrors();
+              setError(processedErrors);
+            }
+            options.onError?.(processedErrors);
+          }
+          throw error;
+        }
+        if (error instanceof HttpCancelledError || error instanceof Error && error.name === "AbortError") {
+          options.onCancel?.();
+          throw new HttpCancelledError("Request was cancelled", url);
+        }
+        throw error;
+      } finally {
+        if (isMounted.current) {
+          finishProcessing();
+        }
+        abortController.current = null;
+        options.onFinish?.();
+      }
+    },
+    [clearErrors, setError]
+  );
+  const cancel = useCallback4(() => {
+    if (abortController.current) {
+      abortController.current.abort();
+    }
+  }, []);
+  const createSubmitMethod = (method) => async (url, options = {}) => {
+    return submit(method, url, options);
+  };
+  const submitWithArgs = useCallback4(
+    (...args2) => {
+      const parsed = UseFormUtils4.parseSubmitArguments(args2, precognitionEndpointRef.current);
+      return submit(parsed.method, parsed.url, parsed.options);
+    },
+    [submit]
+  );
+  Object.assign(baseForm, {
+    response,
+    submit: submitWithArgs,
+    get: createSubmitMethod("get"),
+    post: createSubmitMethod("post"),
+    put: createSubmitMethod("put"),
+    patch: createSubmitMethod("patch"),
+    delete: createSubmitMethod("delete"),
+    cancel,
+    dontRemember: (...keys) => {
+      excludeKeysRef.current = keys;
+      return form;
+    },
+    optimistic: (callback) => {
+      pendingOptimisticRef.current = callback;
+      return form;
+    },
+    withAllErrors: () => {
+      withAllErrors.enable();
+      return form;
+    }
+  });
+  const form = baseForm;
+  const originalWithPrecognition = baseForm.withPrecognition;
+  form.withPrecognition = (...args2) => {
+    originalWithPrecognition(...args2);
+    return form;
+  };
+  return precognitionEndpointRef.current ? form : form;
+}
+
 // src/usePoll.ts
-var import_core8 = require("@inertiajs/core");
-var import_react17 = require("react");
+import { router as router7 } from "@inertiajs/core";
+import { useEffect as useEffect10, useRef as useRef8 } from "react";
 function usePoll(interval, requestOptions = {}, options = {
   keepAlive: false,
   autoStart: true
 }) {
-  const pollRef = (0, import_react17.useRef)(
-    import_core8.router.poll(interval, requestOptions, {
+  const pollRef = useRef8(
+    router7.poll(interval, requestOptions, {
       ...options,
       autoStart: false
     })
   );
-  (0, import_react17.useEffect)(() => {
+  useEffect10(() => {
     if (options.autoStart ?? true) {
       pollRef.current.start();
     }
@@ -1494,21 +1924,21 @@ function usePoll(interval, requestOptions = {}, options = {
 }
 
 // src/usePrefetch.ts
-var import_core9 = require("@inertiajs/core");
-var import_react18 = require("react");
+import { router as router8 } from "@inertiajs/core";
+import { useEffect as useEffect11, useState as useState10 } from "react";
 function usePrefetch(options = {}) {
-  const cached = typeof window === "undefined" ? null : import_core9.router.getCached(window.location.pathname, options);
-  const inFlight = typeof window === "undefined" ? null : import_core9.router.getPrefetching(window.location.pathname, options);
-  const [lastUpdatedAt, setLastUpdatedAt] = (0, import_react18.useState)(cached?.staleTimestamp || null);
-  const [isPrefetching, setIsPrefetching] = (0, import_react18.useState)(inFlight !== null);
-  const [isPrefetched, setIsPrefetched] = (0, import_react18.useState)(cached !== null);
-  (0, import_react18.useEffect)(() => {
-    const onPrefetchingListener = import_core9.router.on("prefetching", (e) => {
+  const cached = typeof window === "undefined" ? null : router8.getCached(window.location.pathname, options);
+  const inFlight = typeof window === "undefined" ? null : router8.getPrefetching(window.location.pathname, options);
+  const [lastUpdatedAt, setLastUpdatedAt] = useState10(cached?.staleTimestamp || null);
+  const [isPrefetching, setIsPrefetching] = useState10(inFlight !== null);
+  const [isPrefetched, setIsPrefetched] = useState10(cached !== null);
+  useEffect11(() => {
+    const onPrefetchingListener = router8.on("prefetching", (e) => {
       if (e.detail.visit.url.pathname === window.location.pathname) {
         setIsPrefetching(true);
       }
     });
-    const onPrefetchedListener = import_core9.router.on("prefetched", (e) => {
+    const onPrefetchedListener = router8.on("prefetched", (e) => {
       if (e.detail.visit.url.pathname === window.location.pathname) {
         setIsPrefetching(false);
         setIsPrefetched(true);
@@ -1524,32 +1954,33 @@ function usePrefetch(options = {}) {
     lastUpdatedAt,
     isPrefetching,
     isPrefetched,
-    flush: () => import_core9.router.flush(window.location.pathname, options)
+    flush: () => router8.flush(window.location.pathname, options)
   };
 }
 
 // src/WhenVisible.ts
-var import_core10 = require("@inertiajs/core");
-var import_react19 = require("react");
+import { router as router9 } from "@inertiajs/core";
+import { get as get3 } from "lodash-es";
+import { createElement as createElement6, useCallback as useCallback5, useEffect as useEffect12, useMemo as useMemo9, useRef as useRef9, useState as useState11 } from "react";
 var WhenVisible = ({ children, data, params, buffer, as, always, fallback }) => {
   always = always ?? false;
   as = as ?? "div";
   fallback = fallback ?? null;
   const pageProps = usePage().props;
-  const keys = (0, import_react19.useMemo)(() => data ? Array.isArray(data) ? data : [data] : [], [data]);
-  const [loaded, setLoaded] = (0, import_react19.useState)(() => keys.length > 0 && keys.every((key) => pageProps[key] !== void 0));
-  const [isFetching, setIsFetching] = (0, import_react19.useState)(false);
-  const fetching = (0, import_react19.useRef)(false);
-  const ref = (0, import_react19.useRef)(null);
-  const observer = (0, import_react19.useRef)(null);
-  const getReloadParamsRef = (0, import_react19.useRef)(() => ({}));
-  (0, import_react19.useEffect)(() => {
+  const keys = useMemo9(() => data ? Array.isArray(data) ? data : [data] : [], [data]);
+  const [loaded, setLoaded] = useState11(() => keys.length > 0 && keys.every((key) => get3(pageProps, key) !== void 0));
+  const [isFetching, setIsFetching] = useState11(false);
+  const fetching = useRef9(false);
+  const ref = useRef9(null);
+  const observer = useRef9(null);
+  const getReloadParamsRef = useRef9(() => ({}));
+  useEffect12(() => {
     if (keys.length > 0) {
-      setLoaded(keys.every((key) => pageProps[key] !== void 0));
+      setLoaded(keys.every((key) => get3(pageProps, key) !== void 0));
     }
   }, [pageProps, keys]);
-  const getReloadParams = (0, import_react19.useCallback)(() => {
-    const reloadParams = { ...params };
+  const getReloadParams = useCallback5(() => {
+    const reloadParams = { preserveErrors: true, ...params };
     if (data) {
       reloadParams.only = Array.isArray(data) ? data : [data];
     }
@@ -1572,7 +2003,7 @@ var WhenVisible = ({ children, data, params, buffer, as, always, fallback }) =>
         fetching.current = true;
         setIsFetching(true);
         const reloadParams = getReloadParamsRef.current();
-        import_core10.router.reload({
+        router9.reload({
           ...reloadParams,
           onStart: (e) => {
             fetching.current = true;
@@ -1596,7 +2027,7 @@ var WhenVisible = ({ children, data, params, buffer, as, always, fallback }) =>
     );
     observer.current.observe(ref.current);
   };
-  (0, import_react19.useEffect)(() => {
+  useEffect12(() => {
     if (!ref.current) {
       return;
     }
@@ -1611,7 +2042,7 @@ var WhenVisible = ({ children, data, params, buffer, as, always, fallback }) =>
   const resolveChildren = () => typeof children === "function" ? children({ fetching: isFetching }) : children;
   const resolveFallback = () => typeof fallback === "function" ? fallback() : fallback;
   if (always || !loaded) {
-    return (0, import_react19.createElement)(
+    return createElement6(
       as,
       {
         props: null,
@@ -1626,7 +2057,30 @@ WhenVisible.displayName = "InertiaWhenVisible";
 var WhenVisible_default = WhenVisible;
 
 // src/index.ts
-var progress = import_core11.progress;
-var router3 = import_core11.router;
-var config = import_core11.config.extend();
+var config = coreConfig.extend();
+export {
+  App,
+  Deferred_default as Deferred,
+  Form_default as Form,
+  Head_default as Head,
+  InfiniteScroll_default as InfiniteScroll,
+  Link_default as Link,
+  WhenVisible_default as WhenVisible,
+  config,
+  createInertiaApp,
+  http2 as http,
+  progress,
+  resetLayoutProps,
+  router3 as router,
+  setLayoutProps,
+  setLayoutPropsFor,
+  useForm,
+  useFormContext,
+  useHttp,
+  useLayoutProps,
+  usePage,
+  usePoll,
+  usePrefetch,
+  useRemember
+};
 //# sourceMappingURL=index.js.map