@inertiajs/core 2.1.0 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inertiajs/core",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "license": "MIT",
   "description": "A framework for creating server-driven single page apps.",
   "contributors": [

package/types/index.d.ts

@@ -1,6 +1,7 @@
 import { Router } from './router';
 export { objectToFormData } from './formData';
 export { formDataToObject } from './formObject';
+export { resetFormFields } from './resetFormFields';
 export { default as createHeadManager } from './head';
 export { hide as hideProgress, reveal as revealProgress, default as setupProgress } from './progress';
 export { default as shouldIntercept } from './shouldIntercept';

package/types/prefetched.d.ts

@@ -8,6 +8,7 @@ declare class PrefetchedRequests {
     add(params: ActiveVisit, sendFunc: (params: InternalActiveVisit) => void, { cacheFor }: PrefetchOptions): Promise<void> | Promise<Response>;
     removeAll(): void;
     remove(params: ActiveVisit): void;
+    protected removeFromInFlight(params: ActiveVisit): void;
     protected extractStaleValues(cacheFor: PrefetchOptions['cacheFor']): [number, number];
     protected cacheForToStaleAndExpires(cacheFor: PrefetchOptions['cacheFor']): [CacheForOption, CacheForOption];
     protected clearTimer(params: ActiveVisit): void;

package/types/requestParams.d.ts

@@ -23,6 +23,7 @@ export declare class RequestParams {
     onStart(): void;
     onPrefetching(): void;
     onPrefetchResponse(response: Response): void;
+    onPrefetchError(error: Error): void;
     all(): InternalActiveVisit;
     headers(): AxiosRequestConfig['headers'];
     setPreserveOptions(page: Page): void;

package/types/resetFormFields.d.ts

@@ -0,0 +1 @@
+export declare function resetFormFields(formElement: HTMLFormElement, defaults: FormData, fieldNames?: string[]): void;

package/types/router.d.ts

@@ -24,13 +24,13 @@ export declare class Router {
     flush(href: string | URL, options?: VisitOptions): void;
     flushAll(): void;
     getPrefetching(href: string | URL, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
-    prefetch(href: string | URL, options: Partial<Visit<RequestPayload> & VisitCallbacks> | undefined, { cacheFor }: PrefetchOptions): void;
+    prefetch(href: string | URL, options: Partial<Visit<RequestPayload> & VisitCallbacks<RequestPayload>> | undefined, { cacheFor }: PrefetchOptions): void;
     clearHistory(): void;
     decryptHistory(): Promise<Page>;
     resolveComponent(component: string): Promise<Component>;
-    replace(params: ClientSideVisitOptions): void;
-    push(params: ClientSideVisitOptions): void;
-    protected clientVisit(params: ClientSideVisitOptions, { replace }?: {
+    replace<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>): void;
+    push<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>): void;
+    protected clientVisit<TProps = Page['props']>(params: ClientSideVisitOptions<TProps>, { replace }?: {
         replace?: boolean;
     }): void;
     protected getPrefetchParams(href: string | URL, options: VisitOptions): ActiveVisit;

package/types/types.d.ts

@@ -5,13 +5,49 @@ declare module 'axios' {
         percentage: number | undefined;
     }
 }
-export type Errors = Record<string, string>;
+export type DefaultInertiaConfig = {
+    errorValueType: string;
+};
+/**
+ * Designed to allow overriding of some core types using TypeScript
+ * interface declaration merging.
+ *
+ * @see {@link DefaultInertiaConfig} for keys to override
+ * @example
+ * ```ts
+ * declare module '@inertiajs/core' {
+ *   export interface InertiaConfig {
+ *     errorValueType: string[]
+ *   }
+ * }
+ * ```
+ */
+export interface InertiaConfig {
+}
+export type InertiaConfigFor<Key extends keyof DefaultInertiaConfig> = Key extends keyof InertiaConfig ? InertiaConfig[Key] : DefaultInertiaConfig[Key];
+export type ErrorValue = InertiaConfigFor<'errorValueType'>;
+export type Errors = Record<string, ErrorValue>;
 export type ErrorBag = Record<string, Errors>;
+export type FormDataConvertibleValue = Blob | FormDataEntryValue | Date | boolean | number | null | undefined;
 export type FormDataConvertible = Array<FormDataConvertible> | {
     [key: string]: FormDataConvertible;
-} | Blob | FormDataEntryValue | Date | boolean | number | null | undefined;
-export type FormDataKeys<T extends Record<any, any>> = T extends T ? keyof T extends infer Key extends Extract<keyof T, string> ? Key extends Key ? T[Key] extends Record<any, any> ? `${Key}.${FormDataKeys<T[Key]>}` | Key : Key : never : never : never;
-export type FormDataValues<T extends Record<any, any>, K extends FormDataKeys<T>> = K extends `${infer P}.${infer Rest}` ? P extends keyof T ? Rest extends FormDataKeys<T[P]> ? FormDataValues<T[P], Rest> : never : never : K extends keyof T ? T[K] : never;
+} | FormDataConvertibleValue;
+export type FormDataType<T extends object> = {
+    [K in keyof T]: T[K] extends FormDataConvertibleValue ? T[K] : T[K] extends (...args: unknown[]) => unknown ? never : T[K] extends object | Array<unknown> ? FormDataType<T[K]> : never;
+};
+export type FormDataKeys<T> = T extends Function | FormDataConvertibleValue ? never : T extends Array<unknown> ? number extends T['length'] ? `${number}` | `${number}.${FormDataKeys<T[number]>}` : Extract<keyof T, `${number}`> | {
+    [Key in Extract<keyof T, `${number}`>]: `${Key & string}.${FormDataKeys<T[Key & string]> & string}`;
+}[Extract<keyof T, `${number}`>] : string extends keyof T ? string : Extract<keyof T, string> | {
+    [Key in Extract<keyof T, string>]: `${Key}.${FormDataKeys<T[Key]> & string}`;
+}[Extract<keyof T, string>];
+type PartialFormDataErrors<T> = {
+    [K in string extends keyof T ? string : Extract<keyof FormDataError<T>, string>]?: ErrorValue;
+};
+export type FormDataErrors<T> = PartialFormDataErrors<T> & {
+    [K in keyof PartialFormDataErrors<T>]: NonNullable<PartialFormDataErrors<T>[K]>;
+};
+export type FormDataValues<T, K extends FormDataKeys<T>> = K extends `${infer P}.${infer Rest}` ? T extends unknown[] ? P extends `${infer I extends number}` ? Rest extends FormDataKeys<T[I]> ? FormDataValues<T[I], Rest> : never : never : P extends keyof T ? Rest extends FormDataKeys<T[P]> ? FormDataValues<T[P], Rest> : never : never : K extends keyof T ? T[K] : T extends unknown[] ? T[K & number] : never;
+export type FormDataError<T> = Partial<Record<FormDataKeys<T>, ErrorValue>>;
 export type Method = 'get' | 'post' | 'put' | 'patch' | 'delete';
 export type RequestPayload = Record<string, FormDataConvertible> | FormData;
 export interface PageProps {
@@ -38,17 +74,17 @@ export type ScrollRegion = {
     top: number;
     left: number;
 };
-export interface ClientSideVisitOptions {
+export interface ClientSideVisitOptions<TProps = Page['props']> {
     component?: Page['component'];
     url?: Page['url'];
-    props?: ((props: Page['props']) => Page['props']) | Page['props'];
+    props?: ((props: TProps) => PageProps) | PageProps;
     clearHistory?: Page['clearHistory'];
     encryptHistory?: Page['encryptHistory'];
     preserveScroll?: VisitOptions['preserveScroll'];
     preserveState?: VisitOptions['preserveState'];
     errorBag?: string | null;
     onError?: (errors: Errors) => void;
-    onFinish?: (visit: ClientSideVisitOptions) => void;
+    onFinish?: (visit: ClientSideVisitOptions<TProps>) => void;
     onSuccess?: (page: Page) => void;
 }
 export type PageResolver = (name: string) => Component;
@@ -81,18 +117,18 @@ export type Visit<T extends RequestPayload = RequestPayload> = {
     reset: string[];
     preserveUrl: boolean;
 };
-export type GlobalEventsMap = {
+export type GlobalEventsMap<T extends RequestPayload = RequestPayload> = {
     before: {
-        parameters: [PendingVisit];
+        parameters: [PendingVisit<T>];
         details: {
-            visit: PendingVisit;
+            visit: PendingVisit<T>;
         };
         result: boolean | void;
     };
     start: {
-        parameters: [PendingVisit];
+        parameters: [PendingVisit<T>];
         details: {
-            visit: PendingVisit;
+            visit: PendingVisit<T>;
         };
         result: void;
     };
@@ -104,9 +140,9 @@ export type GlobalEventsMap = {
         result: void;
     };
     finish: {
-        parameters: [ActiveVisit];
+        parameters: [ActiveVisit<T>];
         details: {
-            visit: ActiveVisit;
+            visit: ActiveVisit<T>;
         };
         result: void;
     };
@@ -151,48 +187,48 @@ export type GlobalEventsMap = {
         result: boolean | void;
     };
     prefetched: {
-        parameters: [AxiosResponse, ActiveVisit];
+        parameters: [AxiosResponse, ActiveVisit<T>];
         details: {
             response: AxiosResponse;
             fetchedAt: number;
-            visit: ActiveVisit;
+            visit: ActiveVisit<T>;
         };
         result: void;
     };
     prefetching: {
-        parameters: [ActiveVisit];
+        parameters: [ActiveVisit<T>];
         details: {
-            visit: ActiveVisit;
+            visit: ActiveVisit<T>;
         };
         result: void;
     };
 };
 export type PageEvent = 'newComponent' | 'firstLoad';
-export type GlobalEventNames = keyof GlobalEventsMap;
-export type GlobalEvent<TEventName extends GlobalEventNames> = CustomEvent<GlobalEventDetails<TEventName>>;
-export type GlobalEventParameters<TEventName extends GlobalEventNames> = GlobalEventsMap[TEventName]['parameters'];
-export type GlobalEventResult<TEventName extends GlobalEventNames> = GlobalEventsMap[TEventName]['result'];
-export type GlobalEventDetails<TEventName extends GlobalEventNames> = GlobalEventsMap[TEventName]['details'];
-export type GlobalEventTrigger<TEventName extends GlobalEventNames> = (...params: GlobalEventParameters<TEventName>) => GlobalEventResult<TEventName>;
-export type GlobalEventCallback<TEventName extends GlobalEventNames> = (...params: GlobalEventParameters<TEventName>) => GlobalEventResult<TEventName>;
+export type GlobalEventNames<T extends RequestPayload = RequestPayload> = keyof GlobalEventsMap<T>;
+export type GlobalEvent<TEventName extends GlobalEventNames<T>, T extends RequestPayload = RequestPayload> = CustomEvent<GlobalEventDetails<TEventName, T>>;
+export type GlobalEventParameters<TEventName extends GlobalEventNames<T>, T extends RequestPayload = RequestPayload> = GlobalEventsMap<T>[TEventName]['parameters'];
+export type GlobalEventResult<TEventName extends GlobalEventNames<T>, T extends RequestPayload = RequestPayload> = GlobalEventsMap<T>[TEventName]['result'];
+export type GlobalEventDetails<TEventName extends GlobalEventNames<T>, T extends RequestPayload = RequestPayload> = GlobalEventsMap<T>[TEventName]['details'];
+export type GlobalEventTrigger<TEventName extends GlobalEventNames<T>, T extends RequestPayload = RequestPayload> = (...params: GlobalEventParameters<TEventName, T>) => GlobalEventResult<TEventName, T>;
+export type GlobalEventCallback<TEventName extends GlobalEventNames<T>, T extends RequestPayload = RequestPayload> = (...params: GlobalEventParameters<TEventName, T>) => GlobalEventResult<TEventName, T>;
 export type InternalEvent = 'missingHistoryItem' | 'loadDeferredProps';
-export type VisitCallbacks = {
+export type VisitCallbacks<T extends RequestPayload = RequestPayload> = {
     onCancelToken: {
         ({ cancel }: {
             cancel: VoidFunction;
         }): void;
     };
-    onBefore: GlobalEventCallback<'before'>;
-    onStart: GlobalEventCallback<'start'>;
-    onProgress: GlobalEventCallback<'progress'>;
-    onFinish: GlobalEventCallback<'finish'>;
-    onCancel: GlobalEventCallback<'cancel'>;
-    onSuccess: GlobalEventCallback<'success'>;
-    onError: GlobalEventCallback<'error'>;
-    onPrefetched: GlobalEventCallback<'prefetched'>;
-    onPrefetching: GlobalEventCallback<'prefetching'>;
+    onBefore: GlobalEventCallback<'before', T>;
+    onStart: GlobalEventCallback<'start', T>;
+    onProgress: GlobalEventCallback<'progress', T>;
+    onFinish: GlobalEventCallback<'finish', T>;
+    onCancel: GlobalEventCallback<'cancel', T>;
+    onSuccess: GlobalEventCallback<'success', T>;
+    onError: GlobalEventCallback<'error', T>;
+    onPrefetched: GlobalEventCallback<'prefetched', T>;
+    onPrefetching: GlobalEventCallback<'prefetching', T>;
 };
-export type VisitOptions<T extends RequestPayload = RequestPayload> = Partial<Visit<T> & VisitCallbacks>;
+export type VisitOptions<T extends RequestPayload = RequestPayload> = Partial<Visit<T> & VisitCallbacks<T>>;
 export type ReloadOptions<T extends RequestPayload = RequestPayload> = Omit<VisitOptions<T>, 'preserveScroll' | 'preserveState'>;
 export type PollOptions = {
     keepAlive?: boolean;
@@ -210,10 +246,11 @@ export type PendingVisitOptions = {
     cancelled: boolean;
     interrupted: boolean;
 };
-export type PendingVisit = Visit & PendingVisitOptions;
-export type ActiveVisit = PendingVisit & Required<VisitOptions>;
+export type PendingVisit<T extends RequestPayload = RequestPayload> = Visit<T> & PendingVisitOptions;
+export type ActiveVisit<T extends RequestPayload = RequestPayload> = PendingVisit<T> & Required<VisitOptions<T>>;
 export type InternalActiveVisit = ActiveVisit & {
     onPrefetchResponse?: (response: Response) => void;
+    onPrefetchError?: (error: Error) => void;
 };
 export type VisitId = unknown;
 export type Component = unknown;
@@ -226,6 +263,16 @@ export type CacheForOption = number | string;
 export type PrefetchOptions = {
     cacheFor: CacheForOption | CacheForOption[];
 };
+export interface LinkComponentBaseProps extends Partial<Pick<Visit<RequestPayload>, 'data' | 'method' | 'replace' | 'preserveScroll' | 'preserveState' | 'only' | 'except' | 'headers' | 'queryStringArrayFormat' | 'async'> & Omit<VisitCallbacks, 'onCancelToken'> & {
+    href: string | {
+        url: string;
+        method: Method;
+    };
+    onCancelToken: (cancelToken: import('axios').CancelTokenSource) => void;
+    prefetch: boolean | LinkPrefetchOption | LinkPrefetchOption[];
+    cacheFor: CacheForOption | CacheForOption[];
+}> {
+}
 type PrefetchObject = {
     params: ActiveVisit;
     response: Promise<Response>;
@@ -264,22 +311,27 @@ export type ProgressSettings = {
     color: string;
 };
 export type FormComponentOptions = Pick<VisitOptions, 'preserveScroll' | 'preserveState' | 'preserveUrl' | 'replace' | 'only' | 'except' | 'reset'>;
-export type FormComponentProps = Partial<Pick<Visit, 'method' | 'headers' | 'queryStringArrayFormat' | 'errorBag' | 'showProgress'> & Omit<VisitCallbacks, 'onPrefetched' | 'onPrefetching'>> & {
+export type FormComponentProps = Partial<Pick<Visit, 'headers' | 'queryStringArrayFormat' | 'errorBag' | 'showProgress'> & Omit<VisitCallbacks, 'onPrefetched' | 'onPrefetching'>> & {
+    method?: Method | Uppercase<Method>;
     action?: string | {
         url: string;
         method: Method;
     };
     transform?: (data: Record<string, FormDataConvertible>) => Record<string, FormDataConvertible>;
     options?: FormComponentOptions;
+    onSubmitComplete?: (props: FormComponentonSubmitCompleteArguments) => void;
+    disableWhileProcessing?: boolean;
 };
 export type FormComponentMethods = {
     clearErrors: (...fields: string[]) => void;
     resetAndClearErrors: (...fields: string[]) => void;
     setError(field: string, value: string): void;
     setError(errors: Record<string, string>): void;
-    reset: () => void;
+    reset: (...fields: string[]) => void;
     submit: () => void;
+    defaults: () => void;
 };
+export type FormComponentonSubmitCompleteArguments = Pick<FormComponentMethods, 'reset' | 'defaults'>;
 export type FormComponentState = {
     errors: Record<string, string>;
     hasErrors: boolean;

package/types/url.d.ts

@@ -1,7 +1,9 @@
 import { FormDataConvertible, Method, RequestPayload, VisitOptions } from './types';
 export declare function hrefToUrl(href: string | URL): URL;
 export declare const transformUrlAndData: (href: string | URL, data: RequestPayload, method: Method, forceFormData: VisitOptions['forceFormData'], queryStringArrayFormat: VisitOptions['queryStringArrayFormat']) => [URL, RequestPayload];
-export declare function mergeDataIntoQueryString(method: Method, href: URL | string, data: Record<string, FormDataConvertible>, qsArrayFormat?: 'indices' | 'brackets'): [string, Record<string, FormDataConvertible>];
+type MergeDataIntoQueryStringDataReturnType<T extends RequestPayload> = T extends Record<string, FormDataConvertible> ? Record<string, FormDataConvertible> : RequestPayload;
+export declare function mergeDataIntoQueryString<T extends RequestPayload>(method: Method, href: URL | string, data: T, qsArrayFormat?: 'indices' | 'brackets'): [string, MergeDataIntoQueryStringDataReturnType<T>];
 export declare function urlWithoutHash(url: URL | Location): URL;
 export declare const setHashIfSameUrl: (originUrl: URL | Location, destinationUrl: URL | Location) => void;
 export declare const isSameUrlWithoutHash: (url1: URL | Location, url2: URL | Location) => boolean;
+export {};