@inertiajs/core 2.1.0 → 2.1.2

package/package.json

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

package/types/index.d.ts

@@ -1,10 +1,11 @@
 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';
 export * from './types';
-export { hrefToUrl, mergeDataIntoQueryString, urlWithoutHash } from './url';
+export { hrefToUrl, mergeDataIntoQueryString, urlWithoutHash, isUrlMethodPair } from './url';
 export { type Router };
 export declare const router: Router;

package/types/prefetched.d.ts

@@ -5,9 +5,11 @@ declare class PrefetchedRequests {
     protected inFlightRequests: InFlightPrefetch[];
     protected removalTimers: PrefetchRemovalTimer[];
     protected currentUseId: string | null;
-    add(params: ActiveVisit, sendFunc: (params: InternalActiveVisit) => void, { cacheFor }: PrefetchOptions): Promise<void> | Promise<Response>;
+    add(params: ActiveVisit, sendFunc: (params: InternalActiveVisit) => void, { cacheFor, cacheTags }: PrefetchOptions): Promise<void> | Promise<Response>;
     removeAll(): void;
+    removeByTags(tags: string[]): 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

@@ -1,14 +1,14 @@
 import { RequestStream } from './requestStream';
-import { ActiveVisit, ClientSideVisitOptions, Component, GlobalEvent, GlobalEventNames, GlobalEventResult, InFlightPrefetch, Page, PendingVisit, PendingVisitOptions, PollOptions, PrefetchedResponse, PrefetchOptions, ReloadOptions, RequestPayload, RouterInitParams, Visit, VisitCallbacks, VisitHelperOptions, VisitOptions } from './types';
+import { ActiveVisit, ClientSideVisitOptions, Component, GlobalEvent, GlobalEventNames, GlobalEventResult, InFlightPrefetch, Page, PendingVisit, PendingVisitOptions, PollOptions, PrefetchedResponse, PrefetchOptions, ReloadOptions, RequestPayload, RouterInitParams, UrlMethodPair, VisitCallbacks, VisitHelperOptions, VisitOptions } from './types';
 export declare class Router {
     protected syncRequestStream: RequestStream;
     protected asyncRequestStream: RequestStream;
     init({ initialPage, resolveComponent, swapComponent }: RouterInitParams): void;
-    get<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    post<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    put<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    patch<T extends RequestPayload = RequestPayload>(url: URL | string, data?: T, options?: VisitHelperOptions<T>): void;
-    delete<T extends RequestPayload = RequestPayload>(url: URL | string, options?: Omit<VisitOptions<T>, 'method'>): void;
+    get<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    post<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    put<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    patch<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, data?: T, options?: VisitHelperOptions<T>): void;
+    delete<T extends RequestPayload = RequestPayload>(url: URL | string | UrlMethodPair, options?: Omit<VisitOptions<T>, 'method'>): void;
     reload<T extends RequestPayload = RequestPayload>(options?: ReloadOptions<T>): void;
     remember(data: unknown, key?: string): void;
     restore(key?: string): unknown;
@@ -19,22 +19,23 @@ export declare class Router {
         stop: VoidFunction;
         start: VoidFunction;
     };
-    visit<T extends RequestPayload = RequestPayload>(href: string | URL, options?: VisitOptions<T>): void;
-    getCached(href: string | URL, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
-    flush(href: string | URL, options?: VisitOptions): void;
+    visit<T extends RequestPayload = RequestPayload>(href: string | URL | UrlMethodPair, options?: VisitOptions<T>): void;
+    getCached(href: string | URL | UrlMethodPair, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
+    flush(href: string | URL | UrlMethodPair, 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;
+    flushByCacheTags(tags: string | string[]): void;
+    getPrefetching(href: string | URL | UrlMethodPair, options?: VisitOptions): InFlightPrefetch | PrefetchedResponse | null;
+    prefetch(href: string | URL | UrlMethodPair, options?: VisitOptions, prefetchOptions?: Partial<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;
-    protected getPendingVisit(href: string | URL, options: VisitOptions, pendingVisitOptions?: Partial<PendingVisitOptions>): PendingVisit;
+    protected getPrefetchParams(href: string | URL | UrlMethodPair, options: VisitOptions): ActiveVisit;
+    protected getPendingVisit(href: string | URL | UrlMethodPair, options: VisitOptions, pendingVisitOptions?: Partial<PendingVisitOptions>): PendingVisit;
     protected getVisitEvents(options: VisitOptions): VisitCallbacks;
     protected loadDeferredProps(): void;
 }

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;
@@ -80,19 +116,20 @@ export type Visit<T extends RequestPayload = RequestPayload> = {
     fresh: boolean;
     reset: string[];
     preserveUrl: boolean;
+    invalidateCacheTags: string | string[];
 };
-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 +141,9 @@ export type GlobalEventsMap = {
         result: void;
     };
     finish: {
-        parameters: [ActiveVisit];
+        parameters: [ActiveVisit<T>];
         details: {
-            visit: ActiveVisit;
+            visit: ActiveVisit<T>;
         };
         result: void;
     };
@@ -151,48 +188,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 +247,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;
@@ -225,7 +263,16 @@ export type LinkPrefetchOption = 'mount' | 'hover' | 'click';
 export type CacheForOption = number | string;
 export type PrefetchOptions = {
     cacheFor: CacheForOption | CacheForOption[];
+    cacheTags: string | string[];
 };
+export interface LinkComponentBaseProps extends Partial<Pick<Visit<RequestPayload>, 'data' | 'method' | 'replace' | 'preserveScroll' | 'preserveState' | 'only' | 'except' | 'headers' | 'queryStringArrayFormat' | 'async'> & Omit<VisitCallbacks, 'onCancelToken'> & {
+    href: string | UrlMethodPair;
+    onCancelToken: (cancelToken: import('axios').CancelTokenSource) => void;
+    prefetch: boolean | LinkPrefetchOption | LinkPrefetchOption[];
+    cacheFor: CacheForOption | CacheForOption[];
+    cacheTags: string | string[];
+}> {
+}
 type PrefetchObject = {
     params: ActiveVisit;
     response: Promise<Response>;
@@ -243,6 +290,7 @@ export type PrefetchedResponse = PrefetchObject & {
     timestamp: number;
     singleUse: boolean;
     inFlight: false;
+    tags: string[];
 };
 export type PrefetchRemovalTimer = {
     params: ActiveVisit;
@@ -263,23 +311,32 @@ export type ProgressSettings = {
     includeCSS: boolean;
     color: string;
 };
+export type UrlMethodPair = {
+    url: string;
+    method: Method;
+};
 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'>> & {
-    action?: string | {
-        url: string;
-        method: Method;
-    };
+export type FormComponentProps = Partial<Pick<Visit, 'headers' | 'queryStringArrayFormat' | 'errorBag' | 'showProgress' | 'invalidateCacheTags'> & Omit<VisitCallbacks, 'onPrefetched' | 'onPrefetching'>> & {
+    method?: Method | Uppercase<Method>;
+    action?: string | UrlMethodPair;
     transform?: (data: Record<string, FormDataConvertible>) => Record<string, FormDataConvertible>;
     options?: FormComponentOptions;
+    onSubmitComplete?: (props: FormComponentonSubmitCompleteArguments) => void;
+    disableWhileProcessing?: boolean;
+    resetOnSuccess?: boolean | string[];
+    resetOnError?: boolean | string[];
+    setDefaultsOnSuccess?: 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,10 @@
-import { FormDataConvertible, Method, RequestPayload, VisitOptions } from './types';
+import { FormDataConvertible, Method, RequestPayload, UrlMethodPair, 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 declare function isUrlMethodPair(href: unknown): href is UrlMethodPair;
+export {};