@inertiajs/vue3 2.3.16 → 3.0.0-beta.1

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 {};

package/types/useHttp.d.ts

@@ -0,0 +1,63 @@
+import { ErrorValue, FormDataErrors, FormDataKeys, FormDataType, FormDataValues, Method, Progress, UrlMethodPair, UseFormTransformCallback, UseFormWithPrecognitionArguments, UseHttpSubmitArguments, UseHttpSubmitOptions } from '@inertiajs/core';
+import { NamedInputEvent, ValidationConfig, Validator } from 'laravel-precognition';
+export interface UseHttpProps<TForm extends object, TResponse = unknown> {
+    isDirty: boolean;
+    errors: FormDataErrors<TForm>;
+    hasErrors: boolean;
+    processing: boolean;
+    progress: Progress | null;
+    wasSuccessful: boolean;
+    recentlySuccessful: boolean;
+    response: TResponse | null;
+    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;
+    submit(...args: UseHttpSubmitArguments<TResponse, TForm>): Promise<TResponse>;
+    get(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    post(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    put(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    patch(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    delete(url: string, options?: UseHttpSubmitOptions<TResponse, TForm>): Promise<TResponse>;
+    cancel(): void;
+    dontRemember<K extends FormDataKeys<TForm>>(...fields: K[]): this;
+    optimistic(callback: (currentData: TForm) => Partial<TForm>): this;
+    withAllErrors(): this;
+    withPrecognition(...args: UseFormWithPrecognitionArguments): UseHttpPrecognitiveProps<TForm, TResponse>;
+}
+type PrecognitionValidationConfig<TKeys> = ValidationConfig & {
+    only?: TKeys[] | Iterable<TKeys> | ArrayLike<TKeys>;
+};
+export interface UseHttpValidationProps<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 UseHttp<TForm extends object, TResponse = unknown> = TForm & UseHttpProps<TForm, TResponse>;
+export type UseHttpPrecognitiveProps<TForm extends object, TResponse = unknown> = UseHttp<TForm, TResponse> & UseHttpValidationProps<TForm> & InternalPrecognitionState;
+export default function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(method: Method | (() => Method), url: string | (() => string), data: TForm | (() => TForm)): UseHttpPrecognitiveProps<TForm, TResponse>;
+export default function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(urlMethodPair: UrlMethodPair | (() => UrlMethodPair), data: TForm | (() => TForm)): UseHttpPrecognitiveProps<TForm, TResponse>;
+export default function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(rememberKey: string, data: TForm | (() => TForm)): UseHttp<TForm, TResponse>;
+export default function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(data: TForm | (() => TForm)): UseHttp<TForm, TResponse>;
+export default function useHttp<TForm extends FormDataType<TForm>, TResponse = unknown>(): UseHttp<TForm, TResponse>;
+export {};