@inertiajs/core 2.3.16 → 3.0.0-beta.1

package/types/types.d.ts

@@ -1,11 +1,38 @@
-import { AxiosProgressEvent, AxiosResponse } from 'axios';
 import { NamedInputEvent, ValidationConfig, Validator } from 'laravel-precognition';
+import type { HttpCancelledError, HttpNetworkError, HttpResponseError } from './httpErrors';
 import { Response } from './response';
-declare module 'axios' {
-    interface AxiosProgressEvent {
-        percentage: number | undefined;
-    }
+export type HttpRequestHeaders = Record<string, unknown>;
+export type HttpResponseHeaders = Record<string, string>;
+export interface HttpProgressEvent {
+    progress: number | undefined;
+    loaded: number;
+    total: number | undefined;
+    percentage?: number;
+}
+export interface HttpRequestConfig {
+    method: Method;
+    url: string;
+    data?: unknown;
+    params?: Record<string, unknown>;
+    headers?: HttpRequestHeaders;
+    signal?: AbortSignal;
+    onUploadProgress?: (event: HttpProgressEvent) => void;
+}
+export interface HttpResponse {
+    status: number;
+    data: string;
+    headers: HttpResponseHeaders;
+}
+export interface HttpClient {
+    request(config: HttpRequestConfig): Promise<HttpResponse>;
+}
+export interface HttpClientOptions {
+    xsrfCookieName?: string;
+    xsrfHeaderName?: string;
 }
+export type HttpRequestHandler = (config: HttpRequestConfig) => HttpRequestConfig | Promise<HttpRequestConfig>;
+export type HttpResponseHandler = (response: HttpResponse) => HttpResponse | Promise<HttpResponse>;
+export type HttpErrorHandler = (error: HttpResponseError | HttpNetworkError | HttpCancelledError) => void | Promise<void>;
 export interface PageFlashData {
     [key: string]: unknown;
 }
@@ -93,14 +120,16 @@ export interface Page<SharedProps extends PageProps = PageProps> {
     };
     url: string;
     version: string | null;
-    clearHistory: boolean;
-    encryptHistory: boolean;
+    clearHistory?: boolean;
+    preserveFragment?: boolean;
+    encryptHistory?: boolean;
     deferredProps?: Record<string, NonNullable<VisitOptions['only']>>;
     initialDeferredProps?: Record<string, NonNullable<VisitOptions['only']>>;
     mergeProps?: string[];
     prependProps?: string[];
     deepMergeProps?: string[];
     matchPropsOn?: string[];
+    sharedProps?: string[];
     scrollProps?: Record<keyof PageProps, ScrollProp>;
     flash: FlashData;
     onceProps?: Record<string, {
@@ -109,6 +138,8 @@ export interface Page<SharedProps extends PageProps = PageProps> {
     }>;
     /** @internal */
     rememberedState: Record<string, unknown>;
+    /** @internal */
+    optimisticUpdatedAt?: Record<string, number>;
 }
 export type ScrollRegion = {
     top: number;
@@ -130,7 +161,7 @@ export interface ClientSideVisitOptions<TProps = Page['props']> {
     onFlash?: (flash: FlashData) => void;
     onSuccess?: (page: Page) => void;
 }
-export type PageResolver = (name: string) => Component;
+export type PageResolver = (name: string, page?: Page) => Component;
 export type PageHandler<ComponentType = Component> = ({ component, page, preserveState, }: {
     component: ComponentType;
     page: Page;
@@ -138,7 +169,7 @@ export type PageHandler<ComponentType = Component> = ({ component, page, preserv
 }) => Promise<unknown>;
 export type PreserveStateOption = boolean | 'errors' | ((page: Page) => boolean);
 export type QueryStringArrayFormatOption = 'indices' | 'brackets';
-export type Progress = AxiosProgressEvent;
+export type Progress = HttpProgressEvent;
 export type LocationVisit = {
     preserveScroll: boolean;
 };
@@ -146,6 +177,7 @@ export type CancelToken = {
     cancel: VoidFunction;
 };
 export type CancelTokenCallback = (cancelToken: CancelToken) => void;
+export type OptimisticCallback<TProps = Page['props']> = (props: TProps) => Partial<TProps> | void;
 export type Visit<T extends RequestPayload = RequestPayload> = {
     method: Method;
     data: T;
@@ -164,8 +196,12 @@ export type Visit<T extends RequestPayload = RequestPayload> = {
     fresh: boolean;
     reset: string[];
     preserveUrl: boolean;
+    preserveErrors: boolean;
     invalidateCacheTags: string | string[];
     viewTransition: boolean | ((viewTransition: ViewTransition) => void);
+    optimistic?: OptimisticCallback;
+    component: string | null;
+    pageProps: Record<string, unknown> | ((currentProps: PageProps, sharedProps: Partial<PageProps>) => Record<string, unknown>) | null;
 };
 export type GlobalEventsMap<T extends RequestPayload = RequestPayload> = {
     before: {
@@ -229,14 +265,14 @@ export type GlobalEventsMap<T extends RequestPayload = RequestPayload> = {
         };
         result: void;
     };
-    invalid: {
-        parameters: [AxiosResponse];
+    httpException: {
+        parameters: [HttpResponse];
         details: {
-            response: AxiosResponse;
+            response: HttpResponse;
         };
         result: boolean | void;
     };
-    exception: {
+    networkError: {
         parameters: [Error];
         details: {
             exception: Error;
@@ -244,9 +280,9 @@ export type GlobalEventsMap<T extends RequestPayload = RequestPayload> = {
         result: boolean | void;
     };
     prefetched: {
-        parameters: [AxiosResponse, ActiveVisit<T>];
+        parameters: [HttpResponse, ActiveVisit<T>];
         details: {
-            response: AxiosResponse;
+            response: HttpResponse;
             fetchedAt: number;
             visit: ActiveVisit<T>;
         };
@@ -286,6 +322,8 @@ export type VisitCallbacks<T extends RequestPayload = RequestPayload> = {
     onCancel: GlobalEventCallback<'cancel', T>;
     onSuccess: GlobalEventCallback<'success', T>;
     onError: GlobalEventCallback<'error', T>;
+    onHttpException: GlobalEventCallback<'httpException', T>;
+    onNetworkError: GlobalEventCallback<'networkError', T>;
     onFlash: GlobalEventCallback<'flash', T>;
     onPrefetched: GlobalEventCallback<'prefetched', T>;
     onPrefetching: GlobalEventCallback<'prefetching', T>;
@@ -310,7 +348,7 @@ export type PendingVisitOptions = {
     interrupted: boolean;
 };
 export type PendingVisit<T extends RequestPayload = RequestPayload> = Visit<T> & PendingVisitOptions;
-export type ActiveVisit<T extends RequestPayload = RequestPayload> = PendingVisit<T> & Required<VisitOptions<T>>;
+export type ActiveVisit<T extends RequestPayload = RequestPayload> = PendingVisit<T> & Required<Omit<VisitOptions<T>, 'optimistic'>>;
 export type InternalActiveVisit = ActiveVisit & {
     onPrefetchResponse?: (response: Response) => void;
     onPrefetchError?: (error: Error) => void;
@@ -323,24 +361,35 @@ type FirstLevelOptional<T> = {
         [P in keyof T[K]]?: T[K][P];
     } : T[K];
 };
-interface CreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
+type PagesOption = string | {
+    path: string;
+    extension?: string | string[];
+    transform?: (name: string) => string;
+};
+export type ProgressOptions = {
+    delay?: number;
+    color?: string;
+    includeCSS?: boolean;
+    showSpinner?: boolean;
+    popover?: boolean | null;
+};
+interface BaseCreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
     resolve: TComponentResolver;
+    pages?: PagesOption;
+    layout?: (name: string, page: Page) => unknown;
     setup: (options: TSetupOptions) => TSetupReturn;
     title?: HeadManagerTitleCallback;
     defaults?: FirstLevelOptional<InertiaAppConfig & TAdditionalInertiaAppConfig>;
+    /** HTTP client or options to use for requests. Defaults to XhrHttpClient. */
+    http?: HttpClient | HttpClientOptions;
 }
-export interface CreateInertiaAppOptionsForCSR<SharedProps extends PageProps, TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> extends CreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
+export interface CreateInertiaAppOptionsForCSR<SharedProps extends PageProps, TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> extends BaseCreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
     id?: string;
     page?: Page<SharedProps>;
-    progress?: false | {
-        delay?: number;
-        color?: string;
-        includeCSS?: boolean;
-        showSpinner?: boolean;
-    };
+    progress?: ProgressOptions | false;
     render?: undefined;
 }
-export interface CreateInertiaAppOptionsForSSR<SharedProps extends PageProps, TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> extends CreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
+export interface CreateInertiaAppOptionsForSSR<SharedProps extends PageProps, TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> extends BaseCreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
     id?: undefined;
     page: Page<SharedProps>;
     progress?: undefined;
@@ -352,11 +401,22 @@ export type InertiaAppSSRResponse = {
 };
 export type InertiaAppResponse = Promise<InertiaAppSSRResponse | void>;
 export type HeadManagerTitleCallback = (title: string) => string;
+export interface CreateInertiaAppOptions<TComponentResolver, TSetupOptions, TSetupReturn, TAdditionalInertiaAppConfig> {
+    id?: string;
+    resolve?: TComponentResolver;
+    pages?: PagesOption;
+    layout?: (name: string, page: Page) => unknown;
+    setup?: (options: TSetupOptions) => TSetupReturn;
+    title?: HeadManagerTitleCallback;
+    progress?: ProgressOptions | false;
+    defaults?: FirstLevelOptional<InertiaAppConfig & TAdditionalInertiaAppConfig>;
+    /** HTTP client or options to use for requests. Defaults to XhrHttpClient. */
+    http?: HttpClient | HttpClientOptions;
+}
 export type HeadManagerOnUpdateCallback = (elements: string[]) => void;
 export type HeadManager = {
     forceUpdate: () => void;
     createProvider: () => {
-        preferredAttribute: () => 'data-inertia' | 'inertia';
         reconnect: () => void;
         update: HeadManagerOnUpdateCallback;
         disconnect: () => void;
@@ -375,20 +435,16 @@ export type InertiaAppConfig = {
         forceIndicesArrayFormatInFormData: boolean;
         withAllErrors: boolean;
     };
-    future: {
-        preserveEqualProps: boolean;
-        useDataInertiaHeadAttribute: boolean;
-        useDialogForErrorModal: boolean;
-        useScriptElementForInitialPage: boolean;
-    };
     prefetch: {
         cacheFor: CacheForOption | CacheForOption[];
         hoverDelay: number;
     };
     visitOptions?: (href: string, options: VisitOptions) => VisitOptions;
 };
-export interface LinkComponentBaseProps extends Partial<Pick<Visit<RequestPayload>, 'data' | 'method' | 'replace' | 'preserveScroll' | 'preserveState' | 'preserveUrl' | 'only' | 'except' | 'headers' | 'queryStringArrayFormat' | 'async' | 'viewTransition'> & VisitCallbacks & {
+export interface LinkComponentBaseProps extends Partial<Pick<Visit<RequestPayload>, 'component' | 'data' | 'method' | 'replace' | 'preserveScroll' | 'preserveState' | 'preserveUrl' | 'only' | 'except' | 'headers' | 'queryStringArrayFormat' | 'async' | 'viewTransition'> & VisitCallbacks & {
     href: string | UrlMethodPair;
+    instant: boolean;
+    pageProps: Record<string, unknown> | ((currentProps: PageProps, sharedProps: Partial<PageProps>) => Record<string, unknown>) | null;
     prefetch: boolean | LinkPrefetchOption | LinkPrefetchOption[];
     cacheFor: CacheForOption | CacheForOption[];
     cacheTags: string | string[];
@@ -421,7 +477,6 @@ export type PrefetchRemovalTimer = {
 export type ProgressSettings = {
     minimum: number;
     easing: string;
-    positionUsing: 'translate3d' | 'translate' | 'margin';
     speed: number;
     trickle: boolean;
     trickleSpeed: number;
@@ -432,10 +487,12 @@ export type ProgressSettings = {
     template: string;
     includeCSS: boolean;
     color: string;
+    popover: boolean | null;
 };
 export type UrlMethodPair = {
     url: string;
     method: Method;
+    component?: string | string[];
 };
 export type UseFormTransformCallback<TForm> = (data: TForm) => object;
 export type UseFormWithPrecognitionArguments = [Method | (() => Method), string | (() => string)] | [UrlMethodPair | (() => UrlMethodPair)];
@@ -444,13 +501,18 @@ type UseFormPrecognitionArguments<TForm> = [urlMethodPair: UrlMethodPair | (() =
 export type UseFormArguments<TForm> = UseFormInertiaArguments<TForm> | UseFormPrecognitionArguments<TForm>;
 export type UseFormSubmitOptions = Omit<VisitOptions, 'data'>;
 export type UseFormSubmitArguments = [Method, string, UseFormSubmitOptions?] | [UrlMethodPair, UseFormSubmitOptions?] | [UseFormSubmitOptions?];
+export type UseHttpSubmitArguments<TResponse = unknown, TForm = unknown> = [Method, string, UseHttpSubmitOptions<TResponse, TForm>?] | [UrlMethodPair, UseHttpSubmitOptions<TResponse, TForm>?] | [UseHttpSubmitOptions<TResponse, TForm>?];
 export type FormComponentOptions = Pick<VisitOptions, 'preserveScroll' | 'preserveState' | 'preserveUrl' | 'replace' | 'only' | 'except' | 'reset' | 'viewTransition'>;
+export type FormComponentOptimisticCallback<TProps = Page['props']> = (props: TProps, formData: Record<string, FormDataConvertible>) => Partial<TProps> | void;
 export type FormComponentProps = Partial<Pick<Visit, 'headers' | 'queryStringArrayFormat' | 'errorBag' | 'showProgress' | 'invalidateCacheTags'> & Omit<VisitCallbacks, 'onPrefetched' | 'onPrefetching'>> & {
     method?: Method | Uppercase<Method>;
     action?: string | UrlMethodPair;
+    component?: string;
+    instant?: boolean;
     transform?: (data: Record<string, FormDataConvertible>) => Record<string, FormDataConvertible>;
+    optimistic?: FormComponentOptimisticCallback;
     options?: FormComponentOptions;
-    onSubmitComplete?: (props: FormComponentonSubmitCompleteArguments) => void;
+    onSubmitComplete?: (props: FormComponentOnSubmitCompleteArguments) => void;
     disableWhileProcessing?: boolean;
     resetOnSuccess?: boolean | string[];
     resetOnError?: boolean | string[];
@@ -459,28 +521,28 @@ export type FormComponentProps = Partial<Pick<Visit, 'headers' | 'queryStringArr
     validationTimeout?: number;
     withAllErrors?: boolean | null;
 };
-export type FormComponentMethods = {
-    clearErrors: (...fields: string[]) => void;
-    resetAndClearErrors: (...fields: string[]) => void;
+export type FormComponentMethods<TForm extends object = Record<string, any>> = {
+    clearErrors: <K extends FormDataKeys<TForm>>(...fields: K[]) => void;
+    resetAndClearErrors: <K extends FormDataKeys<TForm>>(...fields: K[]) => void;
     setError: {
-        (field: string, value: ErrorValue): void;
-        (errors: Record<string, ErrorValue>): void;
+        <K extends FormDataKeys<TForm>>(field: K, value: ErrorValue): void;
+        (errors: FormDataErrors<TForm>): void;
     };
-    reset: (...fields: string[]) => void;
+    reset: <K extends FormDataKeys<TForm>>(...fields: K[]) => void;
     submit: () => void;
     defaults: () => void;
-    getData: () => Record<string, FormDataConvertible>;
+    getData: () => TForm;
     getFormData: () => FormData;
-    valid: (field: string) => boolean;
-    invalid: (field: string) => boolean;
-    validate: (field?: string | NamedInputEvent | ValidationConfig, config?: ValidationConfig) => void;
-    touch: (...fields: string[]) => void;
-    touched: (field?: string) => boolean;
+    valid: <K extends FormDataKeys<TForm>>(field: K) => boolean;
+    invalid: <K extends FormDataKeys<TForm>>(field: K) => boolean;
+    validate: <K extends FormDataKeys<TForm>>(field?: K | NamedInputEvent | ValidationConfig, config?: ValidationConfig) => void;
+    touch: <K extends FormDataKeys<TForm>>(...fields: K[]) => void;
+    touched: <K extends FormDataKeys<TForm>>(field?: K) => boolean;
     validator: () => Validator;
 };
-export type FormComponentonSubmitCompleteArguments = Pick<FormComponentMethods, 'reset' | 'defaults'>;
-export type FormComponentState = {
-    errors: Record<string, ErrorValue>;
+export type FormComponentOnSubmitCompleteArguments<TForm extends object = Record<string, any>> = Pick<FormComponentMethods<TForm>, 'reset' | 'defaults'>;
+export type FormComponentState<TForm extends object = Record<string, any>> = {
+    errors: FormDataErrors<TForm>;
     hasErrors: boolean;
     processing: boolean;
     progress: Progress | null;
@@ -489,14 +551,15 @@ export type FormComponentState = {
     isDirty: boolean;
     validating: boolean;
 };
-export type FormComponentSlotProps = FormComponentMethods & FormComponentState;
-export type FormComponentRef = FormComponentSlotProps;
+export type FormComponentSlotProps<TForm extends object = Record<string, any>> = FormComponentMethods<TForm> & FormComponentState<TForm>;
+export type FormComponentRef<TForm extends object = Record<string, any>> = FormComponentSlotProps<TForm>;
 export interface UseInfiniteScrollOptions {
     getPropName: () => string;
     inReverseMode: () => boolean;
     shouldFetchNext: () => boolean;
     shouldFetchPrevious: () => boolean;
     shouldPreserveUrl: () => boolean;
+    getReloadOptions?: () => ReloadOptions;
     getTriggerMargin: () => number;
     getStartElement: () => HTMLElement;
     getEndElement: () => HTMLElement;
@@ -566,6 +629,20 @@ export interface InfiniteScrollComponentBaseProps {
     onlyNext?: boolean;
     onlyPrevious?: boolean;
 }
+export type UseHttpOptions<TResponse = unknown> = {
+    onBefore?: () => boolean | void;
+    onStart?: () => void;
+    onProgress?: (progress: HttpProgressEvent) => void;
+    onSuccess?: (response: TResponse) => void;
+    onError?: (errors: Errors) => void;
+    onFinish?: () => void;
+    onCancel?: () => void;
+    onCancelToken?: (cancelToken: CancelToken) => void;
+};
+export type UseHttpSubmitOptions<TResponse = unknown, TForm = unknown> = UseHttpOptions<TResponse> & {
+    headers?: HttpRequestHeaders;
+    optimistic?: (currentData: TForm) => Partial<TForm>;
+};
 declare global {
     interface DocumentEventMap {
         'inertia:before': GlobalEvent<'before'>;
@@ -573,8 +650,8 @@ declare global {
         'inertia:progress': GlobalEvent<'progress'>;
         'inertia:success': GlobalEvent<'success'>;
         'inertia:error': GlobalEvent<'error'>;
-        'inertia:invalid': GlobalEvent<'invalid'>;
-        'inertia:exception': GlobalEvent<'exception'>;
+        'inertia:httpException': GlobalEvent<'httpException'>;
+        'inertia:networkError': GlobalEvent<'networkError'>;
         'inertia:finish': GlobalEvent<'finish'>;
         'inertia:beforeUpdate': GlobalEvent<'beforeUpdate'>;
         'inertia:navigate': GlobalEvent<'navigate'>;

package/types/url.d.ts

@@ -8,6 +8,7 @@ export declare const setHashIfSameUrl: (originUrl: URL | Location, destinationUr
 export declare const isSameUrlWithoutHash: (url1: URL | Location, url2: URL | Location) => boolean;
 export declare const isSameUrlWithoutQueryOrHash: (url1: URL | Location, url2: URL | Location) => boolean;
 export declare function isUrlMethodPair(href: unknown): href is UrlMethodPair;
+export declare function resolveUrlMethodPairComponent(pair: UrlMethodPair): string | null;
 export declare function urlHasProtocol(url: string): boolean;
 export declare function urlToString(url: URL | string, absolute: boolean): string;
 export {};

package/types/xhrHttpClient.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient, HttpClientOptions, HttpRequestConfig, HttpResponse } from './types';
+/**
+ * Inertia's built-in HTTP client using XMLHttpRequest
+ */
+export declare class XhrHttpClient implements HttpClient {
+    protected xsrfCookieName: string;
+    protected xsrfHeaderName: string;
+    constructor(options?: HttpClientOptions);
+    request(config: HttpRequestConfig): Promise<HttpResponse>;
+    protected doRequest(config: HttpRequestConfig): Promise<HttpResponse>;
+}
+export declare const xhrHttpClient: XhrHttpClient;