@inertiajs/vue3 2.3.17 → 3.0.0-beta.2

package/dist/server.js

@@ -1,37 +1,6 @@
-"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/server.ts
-var server_exports = {};
-__export(server_exports, {
-  default: () => import_server.default
-});
-module.exports = __toCommonJS(server_exports);
-var import_server = __toESM(require("@inertiajs/core/server"), 1);
+import { default as default2 } from "@inertiajs/core/server";
+export {
+  default2 as default
+};
 //# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/server.ts"],
   "sourcesContent": ["export { default as default } from '@inertiajs/core/server'\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAAmC;",
-  "names": []
+  "mappings": ";AAAA,SAAoB,WAAXA,gBAA0B;",
+  "names": ["default"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inertiajs/vue3",
-  "version": "2.3.17",
+  "version": "3.0.0-beta.2",
   "license": "MIT",
   "description": "The Vue 3 adapter for Inertia.js",
   "contributors": [
@@ -9,7 +9,7 @@
   "homepage": "https://inertiajs.com/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/inertiajs/inertia.git",
+    "url": "git+https://github.com/inertiajs/inertia.git",
     "directory": "packages/vue3"
   },
   "bugs": {
@@ -26,13 +26,11 @@
   "exports": {
     ".": {
       "types": "./types/index.d.ts",
-      "import": "./dist/index.esm.js",
-      "require": "./dist/index.js"
+      "import": "./dist/index.js"
     },
     "./server": {
       "types": "./types/server.d.ts",
-      "import": "./dist/server.esm.js",
-      "require": "./dist/server.js"
+      "import": "./dist/server.js"
     }
   },
   "typesVersions": {
@@ -55,9 +53,9 @@
   },
   "dependencies": {
     "@types/lodash-es": "^4.17.12",
-    "laravel-precognition": "^1.0.2",
+    "laravel-precognition": "2.0.0-beta.3",
     "lodash-es": "^4.17.23",
-    "@inertiajs/core": "2.3.17"
+    "@inertiajs/core": "3.0.0-beta.2"
   },
   "scripts": {
     "build": "pnpm clean && ./build.js && tsc",
@@ -66,6 +64,6 @@
     "dev": "pnpx concurrently -c \"#ffcf00,#3178c6\" \"pnpm dev:build\" \"pnpm dev:types\" --names build,types",
     "dev:build": "./build.js --watch",
     "dev:types": "tsc --watch --preserveWatchOutput",
-    "es2020-check": "pnpm build:with-deps && es-check es2020 \"dist/index.esm.js\" --checkFeatures --module --noCache --verbose"
+    "es2020-check": "pnpm build:with-deps && es-check es2020 \"dist/index.js\" --checkFeatures --module --noCache --verbose"
   }
 }

package/resources/boost/skills/inertia-vue-development/SKILL.blade.php

@@ -1,6 +1,6 @@
 ---
 name: inertia-vue-development
-description: "Develops Inertia.js v2 Vue client-side applications. Activates when creating Vue pages, forms, or navigation; using <Link>, <Form>, useForm, or router; working with deferred props, prefetching, or polling; or when user mentions Vue with Inertia, Vue pages, Vue forms, or Vue navigation."
+description: "Develops Inertia.js v3 Vue client-side applications. Activates when creating Vue pages, forms, or navigation; using <Link>, <Form>, useForm, useHttp, useLayoutProps, or router; working with deferred props, prefetching, optimistic updates, instant visits, or polling; or when user mentions Vue with Inertia, Vue pages, Vue forms, or Vue navigation."
 license: MIT
 metadata:
   author: laravel
@@ -15,14 +15,14 @@ metadata:
 Activate this skill when:
 
 - Creating or modifying Vue page components for Inertia
-- Working with forms in Vue (using `<Form>` or `useForm`)
+- Working with forms in Vue (using `<Form>`, `useForm`, or `useHttp`)
 - Implementing client-side navigation with `<Link>` or `router`
-- Using v2 features: deferred props, prefetching, WhenVisible, InfiniteScroll, once props, flash data, or polling
+- Using v3 features: deferred props, prefetching, optimistic updates, instant visits, layout props, HTTP requests, WhenVisible, InfiniteScroll, once props, flash data, or polling
 - Building Vue-specific features with the Inertia protocol
 
 ## Documentation
 
-Use `search-docs` for detailed Inertia v2 Vue patterns and documentation.
+Use `search-docs` for detailed Inertia v3 Vue patterns and documentation.
 
 ## Basic Usage
 
@@ -293,7 +293,134 @@ function submit() {
 @endboostsnippet
 @endverbatim
 
-## Inertia v2 Features
+## Inertia v3 Features
+
+### HTTP Requests
+
+Use the `useHttp` hook for standalone HTTP requests that do not trigger Inertia page visits. It provides the same developer experience as `useForm`, but for plain JSON endpoints.
+
+@boostsnippet("useHttp Example", "vue")
+<script setup>
+import { useHttp } from '@inertiajs/vue3'
+
+const http = useHttp({
+    query: '',
+})
+
+function search() {
+    http.get('/api/search', {
+        onSuccess: (response) => {
+            console.log(response)
+        },
+    })
+}
+</script>
+
+<template>
+    <input v-model="http.query" @input="search" />
+    <div v-if="http.processing">Searching...</div>
+</template>
+@endboostsnippet
+
+### Optimistic Updates
+
+Apply data changes instantly before the server responds, with automatic rollback on failure:
+
+@boostsnippet("Optimistic Update with Router", "vue")
+<script setup>
+import { router } from '@inertiajs/vue3'
+
+function like(post) {
+    router.optimistic((props) => ({
+        post: {
+            ...props.post,
+            likes: props.post.likes + 1,
+        },
+    })).post(`/posts/${post.id}/like`)
+}
+</script>
+@endboostsnippet
+
+Optimistic updates also work with `useForm` and the `<Form>` component:
+
+@verbatim
+@boostsnippet("Optimistic Update with Form Component", "vue")
+<template>
+    <Form
+        action="/todos"
+        method="post"
+        :optimistic="(props, data) => ({
+            todos: [...props.todos, { id: Date.now(), name: data.name, done: false }],
+        })"
+    >
+        <input type="text" name="name" />
+        <button type="submit">Add Todo</button>
+    </Form>
+</template>
+@endboostsnippet
+@endverbatim
+
+### Instant Visits
+
+Navigate to a new page immediately without waiting for the server response. The target component renders right away with shared props, while page-specific props load in the background.
+
+@boostsnippet("Instant Visit with Link", "vue")
+<script setup>
+import { Link } from '@inertiajs/vue3'
+</script>
+
+<template>
+    <Link href="/dashboard" component="Dashboard">Dashboard</Link>
+
+    <Link
+        href="/posts/1"
+        component="Posts/Show"
+        :page-props="{ post: { id: 1, title: 'My Post' } }"
+    >
+        View Post
+    </Link>
+</template>
+@endboostsnippet
+
+### Layout Props
+
+Share dynamic data between pages and persistent layouts:
+
+@verbatim
+@boostsnippet("Layout Props in Layout", "vue")
+<script setup>
+import { useLayoutProps } from '@inertiajs/vue3'
+
+const layout = useLayoutProps({
+    title: 'My App',
+    showSidebar: true,
+})
+</script>
+
+<template>
+    <header>{{ layout.title }}</header>
+    <aside v-if="layout.showSidebar">Sidebar</aside>
+    <main>
+        <slot />
+    </main>
+</template>
+@endboostsnippet
+@endverbatim
+
+@boostsnippet("Setting Layout Props from Page", "vue")
+<script setup>
+import { setLayoutProps } from '@inertiajs/vue3'
+
+setLayoutProps({
+    title: 'Dashboard',
+    showSidebar: false,
+})
+</script>
+
+<template>
+    <h1>Dashboard</h1>
+</template>
+@endboostsnippet
 
 ### Deferred Props
 
@@ -343,7 +470,7 @@ let interval
 onMounted(() => {
     interval = setInterval(() => {
         router.reload({ only: ['stats'] })
-    }, 5000) // Poll every 5 seconds
+    }, 5000)
 })
 
 onUnmounted(() => {
@@ -378,7 +505,6 @@ defineProps({
     <div>
         <h1>Dashboard</h1>
 
-        <!-- stats prop is loaded only when this section scrolls into view -->
         <WhenVisible data="stats" :buffer="200">
             <template #fallback>
                 <div class="animate-pulse">Loading stats...</div>
@@ -409,3 +535,5 @@ Server-side patterns (Inertia::render, props, middleware) are covered in inertia
 - Not handling the `undefined` state of deferred props before data loads
 - Using `<form>` without preventing default submission (use `<Form>` component or `@submit.prevent`)
 - Forgetting to check if `<Form>` component is available in your Inertia version
+- Using `router.cancel()` instead of `router.cancelAll()` (v3 breaking change)
+- Using `router.on('invalid', ...)` or `router.on('exception', ...)` instead of the renamed `httpException` and `networkError` events

package/types/app.d.ts

@@ -3,9 +3,10 @@ import { DefineComponent, Plugin } from 'vue';
 export interface InertiaAppProps<SharedProps extends PageProps = PageProps> {
     initialPage: Page<SharedProps>;
     initialComponent?: DefineComponent;
-    resolveComponent?: (name: string) => DefineComponent | Promise<DefineComponent>;
+    resolveComponent?: (name: string, page?: Page) => DefineComponent | Promise<DefineComponent>;
     titleCallback?: HeadManagerTitleCallback;
     onHeadUpdate?: HeadManagerOnUpdateCallback;
+    defaultLayout?: (name: string, page: Page) => unknown;
 }
 export type InertiaApp = DefineComponent<InertiaAppProps>;
 declare const App: InertiaApp;

package/types/createInertiaApp.d.ts

@@ -1,9 +1,9 @@
-import { CreateInertiaAppOptionsForCSR, CreateInertiaAppOptionsForSSR, InertiaAppSSRResponse, PageProps } from '@inertiajs/core';
+import { CreateInertiaAppOptions, CreateInertiaAppOptionsForCSR, CreateInertiaAppOptionsForSSR, InertiaAppSSRResponse, Page, PageProps } from '@inertiajs/core';
 import { DefineComponent, Plugin, App as VueApp } from 'vue';
 import { renderToString } from 'vue/server-renderer';
 import { InertiaApp, InertiaAppProps } from './app';
 import { VueInertiaAppConfig } from './types';
-type ComponentResolver = (name: string) => DefineComponent | Promise<DefineComponent> | {
+type ComponentResolver = (name: string, page?: Page) => DefineComponent | Promise<DefineComponent> | {
     default: DefineComponent;
 };
 type SetupOptions<ElementType, SharedProps extends PageProps> = {
@@ -16,6 +16,13 @@ type InertiaAppOptionsForCSR<SharedProps extends PageProps> = CreateInertiaAppOp
 type InertiaAppOptionsForSSR<SharedProps extends PageProps> = CreateInertiaAppOptionsForSSR<SharedProps, ComponentResolver, SetupOptions<null, SharedProps>, VueApp, VueInertiaAppConfig> & {
     render: typeof renderToString;
 };
+type InertiaAppOptionsAuto<SharedProps extends PageProps> = CreateInertiaAppOptions<ComponentResolver, SetupOptions<HTMLElement | null, SharedProps>, VueApp | void, VueInertiaAppConfig> & {
+    page?: Page<SharedProps>;
+    render?: undefined;
+};
+type RenderToString = (app: VueApp) => Promise<string>;
+type RenderFunction<SharedProps extends PageProps> = (page: Page<SharedProps>, renderToString: RenderToString) => Promise<InertiaAppSSRResponse>;
 export default function createInertiaApp<SharedProps extends PageProps = PageProps>(options: InertiaAppOptionsForCSR<SharedProps>): Promise<void>;
 export default function createInertiaApp<SharedProps extends PageProps = PageProps>(options: InertiaAppOptionsForSSR<SharedProps>): Promise<InertiaAppSSRResponse>;
+export default function createInertiaApp<SharedProps extends PageProps = PageProps>(options?: InertiaAppOptionsAuto<SharedProps>): Promise<void | RenderFunction<SharedProps>>;
 export {};

package/types/deferred.d.ts

@@ -1,3 +1,4 @@
+import { type SlotsType } from 'vue';
 declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     data: {
         type: (StringConstructor | {
@@ -16,7 +17,15 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         })[];
         required: true;
     };
-}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, {
+    reloading: import("vue").Ref<boolean, boolean>;
+    slots: Readonly<{
+        default: import("vue").Slot<{
+            reloading: boolean;
+        }>;
+        fallback: import("vue").Slot<{}>;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     data: {
         type: (StringConstructor | {
             (arrayLength: number): String[];
@@ -34,5 +43,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         })[];
         required: true;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>> & Readonly<{}>, {}, SlotsType<{
+    default: {
+        reloading: boolean;
+    };
+    fallback: {};
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;

package/types/form.d.ts

@@ -1,4 +1,4 @@
-import { FormComponentProps, FormComponentRef, FormComponentSlotProps, FormDataConvertible, Method } from '@inertiajs/core';
+import { Errors, FormComponentProps, FormComponentRef, FormComponentSlotProps, FormDataConvertible, Method, VisitOptions } from '@inertiajs/core';
 import { PropType, SlotsType } from 'vue';
 declare const Form: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     action: {
@@ -97,10 +97,22 @@ declare const Form: import("vue").DefineComponent<import("vue").ExtractPropTypes
         type: PropType<FormComponentProps["validationTimeout"]>;
         default: number;
     };
+    optimistic: {
+        type: PropType<FormComponentProps["optimistic"]>;
+        default: undefined;
+    };
     withAllErrors: {
         type: PropType<FormComponentProps["withAllErrors"]>;
         default: null;
     };
+    component: {
+        type: PropType<FormComponentProps["component"]>;
+        default: null;
+    };
+    instant: {
+        type: PropType<FormComponentProps["instant"]>;
+        default: boolean;
+    };
 }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -200,18 +212,36 @@ declare const Form: import("vue").DefineComponent<import("vue").ExtractPropTypes
         type: PropType<FormComponentProps["validationTimeout"]>;
         default: number;
     };
+    optimistic: {
+        type: PropType<FormComponentProps["optimistic"]>;
+        default: undefined;
+    };
     withAllErrors: {
         type: PropType<FormComponentProps["withAllErrors"]>;
         default: null;
     };
+    component: {
+        type: PropType<FormComponentProps["component"]>;
+        default: null;
+    };
+    instant: {
+        type: PropType<FormComponentProps["instant"]>;
+        default: boolean;
+    };
 }>> & Readonly<{}>, {
     transform: ((data: Record<string, FormDataConvertible>) => Record<string, FormDataConvertible>) | undefined;
+    withAllErrors: boolean | null | undefined;
     method: Method | "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | undefined;
+    optimistic: import("@inertiajs/core").FormComponentOptimisticCallback<import("@inertiajs/core").PageProps & {
+        errors: Errors & import("@inertiajs/core").ErrorBag;
+        deferred?: Record<string, VisitOptions["only"]>;
+    }> | undefined;
     headers: Record<string, string> | undefined;
     errorBag: string | null | undefined;
     queryStringArrayFormat: import("@inertiajs/core").QueryStringArrayFormatOption | undefined;
     showProgress: boolean;
     invalidateCacheTags: string | string[] | undefined;
+    component: string | undefined;
     onCancelToken: import("@inertiajs/core").CancelTokenCallback | undefined;
     onBefore: import("@inertiajs/core").GlobalEventCallback<"before", import("@inertiajs/core").RequestPayload> | undefined;
     onStart: import("@inertiajs/core").GlobalEventCallback<"start", import("@inertiajs/core").RequestPayload> | undefined;
@@ -221,17 +251,25 @@ declare const Form: import("vue").DefineComponent<import("vue").ExtractPropTypes
     onSuccess: import("@inertiajs/core").GlobalEventCallback<"success", import("@inertiajs/core").RequestPayload> | undefined;
     onError: import("@inertiajs/core").GlobalEventCallback<"error", import("@inertiajs/core").RequestPayload> | undefined;
     options: import("@inertiajs/core").FormComponentOptions | undefined;
-    withAllErrors: boolean | null | undefined;
     action: string | import("@inertiajs/core").UrlMethodPair | undefined;
     resetOnError: boolean | string[] | undefined;
     resetOnSuccess: boolean | string[] | undefined;
     setDefaultsOnSuccess: boolean | undefined;
-    onSubmitComplete: ((props: import("@inertiajs/core").FormComponentonSubmitCompleteArguments) => void) | undefined;
+    onSubmitComplete: ((props: import("@inertiajs/core").FormComponentOnSubmitCompleteArguments) => void) | undefined;
     validateFiles: boolean | undefined;
     validationTimeout: number | undefined;
+    instant: boolean | undefined;
     disableWhileProcessing: boolean;
 }, SlotsType<{
     default: FormComponentSlotProps;
 }>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-export declare function useFormContext(): FormComponentRef | undefined;
+export declare function useFormContext<TForm extends object = Record<string, any>>(): FormComponentRef<TForm> | undefined;
+type TypedFormComponent<TForm extends Record<string, any>> = typeof Form & {
+    new (): {
+        $slots: {
+            default: (props: FormComponentSlotProps<TForm>) => any;
+        };
+    };
+};
+export declare function createForm<TForm extends Record<string, any>>(): TypedFormComponent<TForm>;
 export default Form;

package/types/index.d.ts

@@ -1,13 +1,15 @@
-export { progress, router } from '@inertiajs/core';
+export { http, progress, router } from '@inertiajs/core';
 export { default as App, usePage } from './app';
 export { default as createInertiaApp } from './createInertiaApp';
 export { default as Deferred } from './deferred';
-export { default as Form, useFormContext } from './form';
+export { createForm, default as Form, useFormContext } from './form';
 export { default as Head } from './head';
 export { default as InfiniteScroll } from './infiniteScroll';
+export { resetLayoutProps, setLayoutProps, setLayoutPropsFor, useLayoutProps } from './layoutProps';
 export { InertiaLinkProps, default as Link } from './link';
-export * from './types';
+export { type VueInertiaAppConfig, type VuePageHandlerArgs } from './types';
 export { InertiaForm, InertiaFormProps, InertiaPrecognitiveForm, default as useForm } from './useForm';
+export { default as useHttp } from './useHttp';
 export { default as usePoll } from './usePoll';
 export { default as usePrefetch } from './usePrefetch';
 export { default as useRemember } from './useRemember';

package/types/infiniteScroll.d.ts

@@ -1,4 +1,4 @@
-import { InfiniteScrollActionSlotProps, InfiniteScrollComponentBaseProps, InfiniteScrollSlotProps } from '@inertiajs/core';
+import { InfiniteScrollActionSlotProps, InfiniteScrollComponentBaseProps, InfiniteScrollSlotProps, ReloadOptions } from '@inertiajs/core';
 import { PropType, SlotsType } from 'vue';
 declare const InfiniteScroll: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     data: {
@@ -53,6 +53,10 @@ declare const InfiniteScroll: import("vue").DefineComponent<import("vue").Extrac
         type: PropType<string | (() => HTMLElement | null | undefined)>;
         default: null;
     };
+    params: {
+        type: PropType<ReloadOptions>;
+        default: () => {};
+    };
 }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
@@ -108,9 +112,14 @@ declare const InfiniteScroll: import("vue").DefineComponent<import("vue").Extrac
         type: PropType<string | (() => HTMLElement | null | undefined)>;
         default: null;
     };
+    params: {
+        type: PropType<ReloadOptions>;
+        default: () => {};
+    };
 }>> & Readonly<{}>, {
     reverse: boolean | undefined;
     preserveUrl: boolean | undefined;
+    params: ReloadOptions;
     buffer: number | undefined;
     as: string | undefined;
     manual: boolean | undefined;

package/types/layoutProps.d.ts

@@ -0,0 +1,13 @@
+import { ComputedRef, InjectionKey } from 'vue';
+export declare function setLayoutProps(props: Record<string, unknown>): void;
+export declare function setLayoutPropsFor(name: string, props: Record<string, unknown>): void;
+export declare function resetLayoutProps(): void;
+export declare const LAYOUT_CONTEXT_KEY: InjectionKey<string | undefined>;
+export declare const LayoutProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    layoutName: StringConstructor;
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    layoutName: StringConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare function useLayoutProps<T extends Record<string, unknown>>(defaults: T): ComputedRef<T>;

package/types/useForm.d.ts

@@ -1,4 +1,4 @@
-import { ErrorValue, FormDataErrors, FormDataKeys, FormDataType, FormDataValues, Method, Progress, UrlMethodPair, UseFormSubmitArguments, UseFormSubmitOptions, UseFormTransformCallback, UseFormWithPrecognitionArguments } from '@inertiajs/core';
+import { ErrorValue, FormDataErrors, FormDataKeys, FormDataType, FormDataValues, Method, OptimisticCallback, Progress, UrlMethodPair, UseFormSubmitArguments, UseFormSubmitOptions, UseFormTransformCallback, UseFormWithPrecognitionArguments } from '@inertiajs/core';
 import { NamedInputEvent, PrecognitionPath, ValidationConfig, Validator } from 'laravel-precognition';
 export interface InertiaFormProps<TForm extends object> {
     isDirty: boolean;
@@ -26,6 +26,7 @@ export interface InertiaFormProps<TForm extends object> {
     delete(url: string, options?: UseFormSubmitOptions): void;
     cancel(): void;
     dontRemember<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    optimistic<TProps>(callback: OptimisticCallback<TProps>): this;
     withPrecognition(...args: UseFormWithPrecognitionArguments): InertiaPrecognitiveForm<TForm>;
 }
 type PrecognitionValidationConfig<TKeys> = ValidationConfig & {

package/types/useFormState.d.ts

@@ -0,0 +1,80 @@
+import { ErrorValue, FormDataErrors, FormDataKeys, FormDataValues, Progress, UrlMethodPair, UseFormTransformCallback, UseFormWithPrecognitionArguments } from '@inertiajs/core';
+import { NamedInputEvent, ValidationConfig, Validator } from 'laravel-precognition';
+type PrecognitionValidationConfig<TKeys> = ValidationConfig & {
+    only?: TKeys[] | Iterable<TKeys> | ArrayLike<TKeys>;
+};
+export interface FormStateProps<TForm extends object> {
+    isDirty: boolean;
+    errors: FormDataErrors<TForm>;
+    hasErrors: boolean;
+    processing: boolean;
+    progress: Progress | null;
+    wasSuccessful: boolean;
+    recentlySuccessful: boolean;
+    data(): TForm;
+    transform(callback: UseFormTransformCallback<TForm>): this;
+    defaults(): this;
+    defaults<T extends FormDataKeys<TForm>>(field: T, value: FormDataValues<TForm, T>): this;
+    defaults(fields: Partial<TForm>): this;
+    reset<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    clearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    resetAndClearErrors<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    setError<K extends FormDataKeys<TForm>>(field: K, value: ErrorValue): this;
+    setError(errors: FormDataErrors<TForm>): this;
+    withPrecognition(...args: UseFormWithPrecognitionArguments): this & FormStateValidationProps<TForm>;
+}
+export interface FormStateValidationProps<TForm extends object> {
+    invalid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    setValidationTimeout(duration: number): this;
+    touch<K extends FormDataKeys<TForm>>(field: K | NamedInputEvent | Array<K>, ...fields: K[]): this;
+    touched<K extends FormDataKeys<TForm>>(field?: K): boolean;
+    valid<K extends FormDataKeys<TForm>>(field: K): boolean;
+    validate<K extends FormDataKeys<TForm>>(field?: K | NamedInputEvent | PrecognitionValidationConfig<K>, config?: PrecognitionValidationConfig<K>): this;
+    validateFiles(): this;
+    validating: boolean;
+    validator: () => Validator;
+    withAllErrors(): this;
+    withoutFileValidation(): this;
+    setErrors(errors: FormDataErrors<TForm> | Record<string, string | string[]>): this;
+    forgetError<K extends FormDataKeys<TForm> | NamedInputEvent>(field: K): this;
+}
+interface InternalPrecognitionState {
+    __touched: string[];
+    __valid: string[];
+}
+export type FormState<TForm extends object> = TForm & FormStateProps<TForm>;
+export type FormStateWithPrecognition<TForm extends object> = FormState<TForm> & FormStateValidationProps<TForm> & InternalPrecognitionState;
+interface InternalRememberState<TForm extends object> {
+    __rememberable: boolean;
+    __remember: () => {
+        data: TForm;
+        errors: FormDataErrors<TForm>;
+    };
+    __restore: (restored: {
+        data: TForm;
+        errors: FormDataErrors<TForm>;
+    }) => void;
+}
+export interface UseFormStateOptions<TForm extends object> {
+    data: TForm | (() => TForm);
+    rememberKey?: string | null;
+    precognitionEndpoint?: (() => UrlMethodPair) | null;
+}
+export interface UseFormStateReturn<TForm extends object> {
+    form: FormState<TForm> & InternalRememberState<TForm>;
+    setDefaults: (newDefaults: TForm) => void;
+    getTransform: () => UseFormTransformCallback<TForm>;
+    getPrecognitionEndpoint: () => (() => UrlMethodPair) | null;
+    markAsSuccessful: () => void;
+    wasDefaultsCalledInOnSuccess: () => boolean;
+    resetDefaultsCalledInOnSuccess: () => void;
+    setRememberExcludeKeys: (keys: FormDataKeys<TForm>[]) => void;
+    resetBeforeSubmit: () => void;
+    finishProcessing: () => void;
+    withAllErrors: {
+        enabled: () => boolean;
+        enable: () => void;
+    };
+}
+export default function useFormState<TForm extends object>(options: UseFormStateOptions<TForm>): UseFormStateReturn<TForm>;
+export {};