inertiax-core 10.2.2 → 11.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inertiax-core",
-  "version": "10.2.2",
+  "version": "11.0.0",
   "license": "MIT",
   "description": "A framework for creating server-driven single page apps.",
   "contributors": [
@@ -9,11 +9,11 @@
     "Sebastian De Deyne <sebastiandedeyne@gmail.com>",
     "Stefan Buhrmester <stefan@buhrmi.de>"
   ],
-  "homepage": "https://github.com/buhrmi/inertiax",
+  "homepage": "https://inertiajs.com/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/buhrmi/inertiax.git",
-    "directory": "packages/core"
+    "url": "git+https://github.com/buhrmi/inertiax.git",
+    "directory": "packages/inertia"
   },
   "bugs": {
     "url": "https://github.com/buhrmi/inertiax/issues"
@@ -28,41 +28,57 @@
   "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"
+    },
+    "./ssrErrors": {
+      "types": "./types/ssrErrors.d.ts",
+      "import": "./dist/ssrErrors.js"
     }
   },
   "typesVersions": {
     "*": {
       "server": [
         "types/server.d.ts"
+      ],
+      "ssrErrors": [
+        "types/ssrErrors.d.ts"
       ]
     }
   },
-  "scripts": {
-    "dev": "./build.js --watch",
-    "build": "npm run clean && ./build.js && tsc --emitDeclarationOnly",
-    "clean": "rm -rf types && rm -rf dist",
-    "prepublishOnly": "npm run build",
-    "test": "vitest"
-  },
   "dependencies": {
-    "axios": "^1.8.2",
-    "es-toolkit": "^1.34.1",
-    "qs": "^6.9.0"
+    "@jridgewell/trace-mapping": "^0.3.31",
+    "es-toolkit": "^1.33.0",
+    "laravel-precognition": "^2.0.0"
+  },
+  "peerDependencies": {
+    "axios": "^1.15.2"
+  },
+  "peerDependenciesMeta": {
+    "axios": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@types/deepmerge": "^2.2.0",
-    "@types/node": "^18.4",
-    "@types/nprogress": "^0.2.0",
-    "@types/qs": "^6.9.0",
-    "esbuild": "^0.25.0",
-    "esbuild-node-externals": "^1.6.0",
-    "typescript": "^4.9.4"
+    "@types/node": "^24.10.13",
+    "axios": "^1.15.2",
+    "es-check": "^9.6.4",
+    "esbuild": "^0.27.3",
+    "esbuild-node-externals": "^1.20.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.2"
+  },
+  "scripts": {
+    "build": "pnpm clean && ./build.js && tsc",
+    "build:with-deps": "./build.js --with-deps",
+    "clean": "rm -rf types && rm -rf dist",
+    "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",
+    "es2022-check": "pnpm build:with-deps && es-check es2022 \"dist/index.js\" --checkFeatures --module --noCache --verbose",
+    "test": "vitest run"
   }
-}
+}

package/readme.md

@@ -1,5 +1,5 @@
-# Inertia X
+# Inertia.js
 
-Inertia X lets you quickly build modern single-page React, Vue and Svelte apps using classic server-side routing and controllers.
+Inertia.js lets you quickly build modern single-page Svelte apps using classic server-side routing and controllers.
 
 Visit [inertiajs.com](https://inertiajs.com/) to learn more.

package/types/axiosHttpClient.d.ts

@@ -0,0 +1,13 @@
+import type { AxiosInstance } from 'axios';
+import { HttpClient, HttpRequestConfig, HttpResponse } from './types';
+export declare class AxiosHttpClient implements HttpClient {
+    private axiosInstance;
+    constructor(instance?: AxiosInstance);
+    private getAxios;
+    request(config: HttpRequestConfig): Promise<HttpResponse>;
+    protected doRequest(config: HttpRequestConfig): Promise<HttpResponse>;
+}
+/**
+ * Create an Axios HTTP client adapter
+ */
+export declare function axiosAdapter(instance?: AxiosInstance): HttpClient;

package/types/config.d.ts

@@ -0,0 +1,24 @@
+import { InertiaAppConfig } from './types';
+type ConfigKeys<T> = T extends Function ? never : string extends keyof T ? string : Extract<keyof T, string> | {
+    [Key in Extract<keyof T, string>]: T[Key] extends object ? `${Key}.${ConfigKeys<T[Key]> & string}` : never;
+}[Extract<keyof T, string>];
+type ConfigValue<T, K extends ConfigKeys<T>> = K extends `${infer P}.${infer Rest}` ? P extends keyof T ? Rest extends ConfigKeys<T[P]> ? ConfigValue<T[P], Rest> : never : never : K extends keyof T ? T[K] : never;
+type ConfigSetObject<T> = {
+    [K in ConfigKeys<T>]?: ConfigValue<T, K>;
+};
+type FirstLevelOptional<T> = {
+    [K in keyof T]?: T[K] extends object ? {
+        [P in keyof T[K]]?: T[K][P];
+    } : T[K];
+};
+export declare class Config<TConfig extends {} = {}> {
+    protected config: FirstLevelOptional<TConfig>;
+    protected defaults: TConfig;
+    constructor(defaults: TConfig);
+    extend<TExtension extends {}>(defaults?: TExtension): Config<TConfig & TExtension>;
+    replace(newConfig: FirstLevelOptional<TConfig>): void;
+    get<K extends ConfigKeys<TConfig>>(key: K): ConfigValue<TConfig, K>;
+    set<K extends ConfigKeys<TConfig>>(keyOrValues: K | Partial<ConfigSetObject<TConfig>>, value?: ConfigValue<TConfig, K>): void;
+}
+export declare const config: Config<InertiaAppConfig>;
+export {};

package/types/debug.d.ts

@@ -1 +1 @@
-export declare const stackTrace: (autolog?: boolean) => any;
+export declare const stackTrace: (autolog?: boolean) => string | undefined;

package/types/dialog.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    createIframeAndPage(html: Record<string, unknown> | string): {
+        iframe: HTMLIFrameElement;
+        page: HTMLElement;
+    };
+    show(html: Record<string, unknown> | string): void;
+};
+export default _default;

package/types/domUtils.d.ts

@@ -0,0 +1,4 @@
+export declare const getScrollableParent: (element: HTMLElement | null) => HTMLElement | null;
+export declare const getElementsInViewportFromCollection: (elements: HTMLElement[], referenceElement?: HTMLElement) => HTMLElement[];
+export declare const requestAnimationFrame: (cb: () => void, times?: number) => void;
+export declare const getInitialPageFromDOM: <T>(id: string) => T | null;

package/types/eventHandler.d.ts

@@ -1,20 +1,21 @@
 import { GlobalEvent, GlobalEventNames, GlobalEventResult, InternalEvent } from './types';
-declare global {
-    interface PopStateEvent {
-        skipInertia?: boolean;
-    }
-}
 declare class EventHandler {
+    protected initialized: boolean;
     protected internalListeners: {
         event: InternalEvent;
-        listener: VoidFunction;
+        listener: (...args: any[]) => void;
     }[];
+    protected popstateHandlers: Map<string, (state: any) => void>;
+    protected pageshowHandlers: Map<string, () => void>;
     init(): void;
-    onGlobalEvent<TEventName extends GlobalEventNames>(frame: string, type: TEventName, callback: (event: GlobalEvent<TEventName>) => GlobalEventResult<TEventName>): VoidFunction;
-    on(event: InternalEvent, callback: VoidFunction): VoidFunction;
-    onMissingHistoryItem(): void;
-    fireInternalEvent(event: InternalEvent): void;
+    onGlobalEvent<TEventName extends GlobalEventNames>(type: TEventName, callback: (event: GlobalEvent<TEventName>) => GlobalEventResult<TEventName>): VoidFunction;
+    on(event: InternalEvent, callback: (...args: any[]) => void): VoidFunction;
+    registerPopstateHandler(frameId: string, callback: (state: any) => void): VoidFunction;
+    registerPageshowHandler(frameId: string, callback: () => void): VoidFunction;
+    onMissingHistoryItem(frameId?: string): void;
+    fireInternalEvent(event: InternalEvent, ...args: any[]): void;
     protected registerListener(type: string, listener: EventListener): VoidFunction;
+    protected handlePageshowEvent(event: PageTransitionEvent): void;
     protected handlePopstateEvent(event: PopStateEvent): void;
 }
 export declare const eventHandler: EventHandler;

package/types/events.d.ts

@@ -1,12 +1,14 @@
 import { GlobalEventTrigger } from './types';
 export declare const fireBeforeEvent: GlobalEventTrigger<'before'>;
 export declare const fireErrorEvent: GlobalEventTrigger<'error'>;
-export declare const fireExceptionEvent: GlobalEventTrigger<'exception'>;
+export declare const fireNetworkErrorEvent: GlobalEventTrigger<'networkError'>;
 export declare const fireFinishEvent: GlobalEventTrigger<'finish'>;
-export declare const fireInvalidEvent: GlobalEventTrigger<'invalid'>;
+export declare const fireHttpExceptionEvent: GlobalEventTrigger<'httpException'>;
+export declare const fireBeforeUpdateEvent: GlobalEventTrigger<'beforeUpdate'>;
 export declare const fireNavigateEvent: GlobalEventTrigger<'navigate'>;
 export declare const fireProgressEvent: GlobalEventTrigger<'progress'>;
 export declare const fireStartEvent: GlobalEventTrigger<'start'>;
 export declare const fireSuccessEvent: GlobalEventTrigger<'success'>;
 export declare const firePrefetchedEvent: GlobalEventTrigger<'prefetched'>;
 export declare const firePrefetchingEvent: GlobalEventTrigger<'prefetching'>;
+export declare const fireFlashEvent: GlobalEventTrigger<'flash'>;

package/types/files.d.ts

@@ -1,2 +1,3 @@
 import { FormDataConvertible, RequestPayload } from './types';
+export declare const isFile: (value: unknown) => boolean;
 export declare function hasFiles(data: RequestPayload | FormDataConvertible): boolean;

package/types/formData.d.ts

@@ -1,3 +1,3 @@
-import { FormDataConvertible } from './types';
+import type { FormDataConvertible, QueryStringArrayFormatOption } from './types';
 export declare const isFormData: (value: any) => value is FormData;
-export declare function objectToFormData(source: Record<string, FormDataConvertible>, form?: FormData, parentKey?: string | null): FormData;
+export declare function objectToFormData(source: Record<string, FormDataConvertible>, form?: FormData, parentKey?: string | null, queryStringArrayFormat?: QueryStringArrayFormatOption): FormData;

package/types/formObject.d.ts

@@ -0,0 +1,5 @@
+import { FormDataConvertible } from './types';
+/**
+ * Convert a FormData instance into an object structure.
+ */
+export declare function formDataToObject(source: FormData): Record<string, FormDataConvertible>;

package/types/head.d.ts

@@ -1,7 +1,2 @@
-export default function createHeadManager(isServer: boolean, titleCallback: (title: string) => string, onUpdate: (elements: string[]) => void): {
-    forceUpdate: () => void;
-    createProvider: () => {
-        update: (elements: string[]) => void;
-        disconnect: () => void;
-    };
-};
+import { HeadManager, HeadManagerOnUpdateCallback, HeadManagerTitleCallback } from '.';
+export default function createHeadManager(isServer: boolean, titleCallback: HeadManagerTitleCallback, onUpdate: HeadManagerOnUpdateCallback): HeadManager;

package/types/history.d.ts

@@ -1,52 +1,64 @@
-import { Page, ScrollRegion, Frames } from './types';
+import { Page, ScrollRegion } from './types';
+type FrameHistoryState = {
+    page: Page | ArrayBuffer;
+    scrollRegions?: ScrollRegion[];
+    documentScrollPosition?: ScrollRegion;
+};
+type InertiaHistoryState = {
+    frames: Record<string, FrameHistoryState>;
+};
 declare class History {
     rememberedState: "rememberedState";
     scrollRegions: "scrollRegions";
     preserveUrl: boolean;
-    counter: any;
-    externalCallbacks: Array<{
-        arrive: () => void;
-        recede: () => void;
-    }>;
-    lastChangedFrames: string[];
-    protected current: Frames;
-    protected initialState: Partial<Frames> | null;
-    remember(frame: string, data: unknown, key: string): void;
-    restore(frame: string, key: string): unknown;
-    pushExternal(src: string, { arrive, recede }: {
-        arrive: () => void;
-        recede: () => void;
-    }): void;
-    pushState(frame: string, page: Page, cb?: (() => void) | null): void;
-    removeFrame(frame: string): void;
-    protected getFramesData(frames: Frames, encrypt: boolean): Promise<Frames | ArrayBuffer>;
+    protected current: Map<string, Partial<Page<import("./types").PageProps>>>;
+    protected initialState: Map<string, Partial<Page<import("./types").PageProps>> | null>;
+    protected getCurrent(frameId: string): Partial<Page>;
+    protected setCurrentState(page: Partial<Page>, frameId: string): void;
+    protected getInitial(frameId: string): Partial<Page> | null;
+    protected setInitial(page: Partial<Page> | null, frameId: string): void;
+    protected getWindowState(): InertiaHistoryState;
+    protected getFrameState(frameId?: string): FrameHistoryState | null;
+    remember(data: unknown, key: string, frameId?: string): void;
+    restore(key: string, frameId?: string): unknown;
+    pushState(page: Page, cb?: (() => void) | null, frameId?: string, browserUrl?: string): void;
+    protected clonePageProps(page: Page): Page;
+    protected getPageData(page: Page): Promise<Page | ArrayBuffer>;
     processQueue(): Promise<void>;
-    decrypt(frames?: Frames | null): Promise<Frames>;
-    protected decryptPageData(framesData: ArrayBuffer | Frames | null): Promise<Frames | null>;
-    saveScrollPositions(scrollRegions: ScrollRegion[]): void;
-    saveDocumentScrollPosition(scrollRegion: ScrollRegion): void;
-    getScrollRegions(): ScrollRegion[];
-    getDocumentScrollPosition(): ScrollRegion;
-    replaceState(frame: string, page: Page, cb?: (() => void) | null): void;
+    decrypt(page?: Page | ArrayBuffer | null, frameId?: string): Promise<Page>;
+    protected decryptPageData(pageData: ArrayBuffer | Page | null): Promise<Page | null>;
+    saveScrollPositions(scrollRegions: ScrollRegion[], frameId?: string): void;
+    saveDocumentScrollPosition(scrollRegion: ScrollRegion, frameId?: string): void;
+    getScrollRegions(frameId?: string): ScrollRegion[];
+    getDocumentScrollPosition(frameId?: string): ScrollRegion;
+    replaceState(page: Page, cb?: (() => void) | null, frameId?: string, browserUrl?: string): void;
+    protected isHistoryThrottleError(error: unknown): error is Error & {
+        name: 'SecurityError';
+    };
+    protected isQuotaExceededError(error: unknown): error is Error & {
+        name: 'QuotaExceededError';
+    };
+    protected withThrottleProtection<T = void>(cb: () => T): Promise<T | undefined>;
     protected doReplaceState(data: {
-        frames: Frames | ArrayBuffer;
+        page: Page | ArrayBuffer;
         scrollRegions?: ScrollRegion[];
         documentScrollPosition?: ScrollRegion;
-        changedFrames?: string[];
-    }, url?: string): void;
+    }, url?: string, frameId?: string): Promise<void>;
     protected doPushState(data: {
-        frames: Frames | ArrayBuffer;
+        page: Page | ArrayBuffer;
         scrollRegions?: ScrollRegion[];
         documentScrollPosition?: ScrollRegion;
-        changedFrames?: string[];
-    }, url: string): void;
-    getState<T>(key: keyof Page, defaultValue?: T): any;
-    deleteState(key: keyof Page): void;
-    hasAnyState(): boolean;
+    }, url: string, frameId?: string): Promise<void>;
+    getState<T>(key: keyof Page, defaultValue?: T, frameId?: string): any;
+    deleteState(key: keyof Page, frameId?: string): void;
+    clearInitialState(key: keyof Page, frameId?: string): void;
+    browserHasHistoryEntry(frameId?: string): boolean;
     clear(): void;
-    setCurrent(frame: string, page: Page): void;
-    isValidState(state: any): boolean;
-    getAllState(): Page;
+    setCurrent(page: Page, frameId?: string): void;
+    isValidState(state: any, frameId?: string): boolean;
+    getAllState(frameId?: string): Page;
+    getStateForFrame(state: any, frameId?: string): FrameHistoryState | null;
+    deleteFrame(frameId: string): void;
 }
 export declare const history: History;
 export {};

package/types/http.d.ts

@@ -0,0 +1,38 @@
+import { HttpClient, HttpClientOptions } from './types';
+export declare const http: {
+    /**
+     * Get the current HTTP client
+     */
+    getClient(): HttpClient;
+    /**
+     * Set the HTTP client to use for all Inertia requests
+     */
+    setClient(clientOrOptions: HttpClient | HttpClientOptions): void;
+    /**
+     * Register a request handler that runs before each request
+     */
+    onRequest: (handler: import("./types").HttpRequestHandler) => () => void;
+    /**
+     * Register a response handler that runs after each successful response
+     */
+    onResponse: (handler: import("./types").HttpResponseHandler) => () => void;
+    /**
+     * Register an error handler that runs when a request fails
+     */
+    onError: (handler: import("./types").HttpErrorHandler) => () => void;
+    /**
+     * Process a request config through all registered request handlers.
+     * For use by custom HttpClient implementations.
+     */
+    processRequest: (config: import("./types").HttpRequestConfig) => Promise<import("./types").HttpRequestConfig>;
+    /**
+     * Process a response through all registered response handlers.
+     * For use by custom HttpClient implementations.
+     */
+    processResponse: (response: import("./types").HttpResponse) => Promise<import("./types").HttpResponse>;
+    /**
+     * Process an error through all registered error handlers.
+     * For use by custom HttpClient implementations.
+     */
+    processError: (error: import("./httpErrors").HttpResponseError | import("./httpErrors").HttpNetworkError | import("./httpErrors").HttpCancelledError) => Promise<void>;
+};

package/types/httpErrors.d.ts

@@ -0,0 +1,17 @@
+import { HttpResponse } from './types';
+export declare class HttpError extends Error {
+    readonly code: string;
+    readonly url?: string;
+    constructor(message: string, code: string, url?: string);
+}
+export declare class HttpResponseError extends HttpError {
+    readonly response: HttpResponse;
+    constructor(message: string, response: HttpResponse, url?: string);
+}
+export declare class HttpCancelledError extends HttpError {
+    constructor(message?: string, url?: string);
+}
+export declare class HttpNetworkError extends HttpError {
+    readonly cause?: Error;
+    constructor(message: string, url?: string, cause?: Error);
+}

package/types/httpHandlers.d.ts

@@ -0,0 +1,15 @@
+import { HttpCancelledError, HttpNetworkError, HttpResponseError } from './httpErrors';
+import { HttpErrorHandler, HttpRequestConfig, HttpRequestHandler, HttpResponse, HttpResponseHandler } from './types';
+declare class HttpHandlers {
+    protected requestHandlers: HttpRequestHandler[];
+    protected responseHandlers: HttpResponseHandler[];
+    protected errorHandlers: HttpErrorHandler[];
+    onRequest(handler: HttpRequestHandler): () => void;
+    onResponse(handler: HttpResponseHandler): () => void;
+    onError(handler: HttpErrorHandler): () => void;
+    processRequest(config: HttpRequestConfig): Promise<HttpRequestConfig>;
+    processResponse(response: HttpResponse): Promise<HttpResponse>;
+    processError(error: HttpResponseError | HttpNetworkError | HttpCancelledError): Promise<void>;
+}
+export declare const httpHandlers: HttpHandlers;
+export {};

package/types/index.d.ts

@@ -1,8 +1,25 @@
+import { Config } from './config';
 import { Router } from './router';
-export { history } from './history';
+export { UseFormUtils } from './useFormUtils';
+export { axiosAdapter } from './axiosHttpClient';
+export { config } from './config';
+export { getInitialPageFromDOM, getScrollableParent } from './domUtils';
+export { hasFiles } from './files';
+export { objectToFormData } from './formData';
+export { formDataToObject } from './formObject';
 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 { http } from './http';
+export { HttpCancelledError, HttpError, HttpNetworkError, HttpResponseError } from './httpErrors';
+export { default as useInfiniteScroll } from './infiniteScroll';
+export { createLayoutPropsStore, isPropsObject, isPropsObjectOrCallback, normalizeLayouts, type LayoutCallbackReturn, type LayoutDefinition, type LayoutPropsStore, } from './layout';
+export { shouldIntercept, shouldNavigate } from './navigationEvents';
+export { isPathOrSubPath, partialReloadRequestsProp, partialReloadRequestsSomeProps } from './partialReload';
+export { progress, default as setupProgress } from './progress';
+export { FormComponentResetSymbol, resetFormFields } from './resetFormFields';
+export { buildSSRBody } from './ssrUtils';
 export * from './types';
-export { hrefToUrl, mergeDataIntoQueryString, urlWithoutHash } from './url';
-export { Router };
+export { hrefToUrl, isSameUrlWithoutQueryOrHash, isUrlMethodPair, mergeDataIntoQueryString, resolveUrlMethodPairComponent, urlHasProtocol, urlToString, urlWithoutHash, } from './url';
+export { XhrHttpClient, xhrHttpClient } from './xhrHttpClient';
+export { type Config, type Router };
+export declare const router: Router;
+export declare function createRouter(frameId?: string): Router;

package/types/infiniteScroll/data.d.ts

@@ -0,0 +1,19 @@
+import { UseInfiniteScrollDataManager } from '../types';
+export type InfiniteScrollPageIdentifier = string | number | null;
+export type InfiniteScrollOnCompleteDetails = {
+    page: InfiniteScrollPageIdentifier;
+    completed: boolean;
+};
+export declare const useInfiniteScrollData: (options: {
+    getPropName: () => string;
+    onBeforeUpdate: () => void;
+    onBeforePreviousRequest: () => void;
+    onBeforeNextRequest: () => void;
+    onCompletePreviousRequest: (
+    /** @deprecated Use `details.page` instead. The positional `loadedPage` argument will be removed in the next major version. */
+    loadedPage: InfiniteScrollPageIdentifier, details: InfiniteScrollOnCompleteDetails) => void;
+    onCompleteNextRequest: (
+    /** @deprecated Use `details.page` instead. The positional `loadedPage` argument will be removed in the next major version. */
+    loadedPage: InfiniteScrollPageIdentifier, details: InfiniteScrollOnCompleteDetails) => void;
+    onReset?: () => void;
+}) => UseInfiniteScrollDataManager;

package/types/infiniteScroll/elements.d.ts

@@ -0,0 +1,15 @@
+import { UseInfiniteScrollElementManager } from '../types';
+export declare const getPageFromElement: (element: HTMLElement) => string | undefined;
+export declare const useInfiniteScrollElementManager: (options: {
+    shouldFetchNext: () => boolean;
+    shouldFetchPrevious: () => boolean;
+    getTriggerMargin: () => number;
+    getStartElement: () => HTMLElement;
+    getEndElement: () => HTMLElement;
+    getItemsElement: () => HTMLElement;
+    getScrollableParent: () => HTMLElement | null;
+    onPreviousTriggered: () => void;
+    onNextTriggered: () => void;
+    onItemIntersected: (element: HTMLElement) => void;
+    getPropName: () => string;
+}) => UseInfiniteScrollElementManager;

package/types/infiniteScroll/queryString.d.ts

@@ -0,0 +1,13 @@
+/**
+ * As users scroll through infinite content, this system updates the URL to reflect
+ * which page they're currently viewing. It uses a "most visible page" calculation
+ * so that the URL reflects whichever page has the most visible items.
+ */
+export declare const useInfiniteScrollQueryString: (options: {
+    getPageName: () => string;
+    getItemsElement: () => HTMLElement;
+    shouldPreserveUrl: () => boolean;
+}) => {
+    onItemIntersected: (itemElement: HTMLElement) => void;
+    cancel: () => boolean;
+};

package/types/infiniteScroll/scrollPreservation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * When loading content "before" the current viewport (e.g. loading page 1 when viewing page 2),
+ * new content is prepended to the DOM, which naturally pushes existing content down and
+ * disrupts the user's scroll position. This system maintains visual stability by:
+ *
+ * 1. Capturing a reference element and its position before the update
+ * 2. After new content is added, calculating how far that reference element moved
+ * 3. Adjusting scroll position to keep the reference element in the same visual location
+ */
+export declare const useInfiniteScrollPreservation: (options: {
+    getScrollableParent: () => HTMLElement | null;
+    getItemsElement: () => HTMLElement;
+}) => {
+    createCallbacks: () => {
+        captureScrollPosition: () => void;
+        restoreScrollPosition: () => void;
+    };
+};

package/types/infiniteScroll.d.ts

@@ -0,0 +1,12 @@
+import { UseInfiniteScrollOptions, UseInfiniteScrollProps } from './types';
+/**
+ * Core infinite scroll composable that orchestrates data fetching, DOM management,
+ * scroll preservation, and URL synchronization.
+ *
+ * This is the main entry point that coordinates four sub-systems:
+ * - Data management: Handles pagination state and server requests
+ * - Element management: DOM observation and intersection detection
+ * - Query string sync: Updates URL as user scrolls through pages
+ * - Scroll preservation: Maintains scroll position during content updates
+ */
+export default function useInfiniteScroll(options: UseInfiniteScrollOptions): UseInfiniteScrollProps;

package/types/initialVisit.d.ts

@@ -1,10 +1,11 @@
 export declare class InitialVisit {
-    static handle(): void;
-    protected static clearRememberedStateOnReload(): void;
-    protected static handleBackForward(): boolean;
+    static handle(frameId?: string): void;
+    protected static clearRememberedStateOnReload(frameId?: string): void;
+    protected static handleBackForward(frameId?: string): boolean;
     /**
      * @link https://inertiajs.com/redirects#external-redirects
      */
-    protected static handleLocation(): boolean;
-    protected static handleDefault(): void;
+    protected static handleLocation(frameId?: string): boolean;
+    protected static handleDefault(frameId?: string): void;
+    protected static fireInitialEvents(frameId?: string): void;
 }

package/types/intersectionObservers.d.ts

@@ -0,0 +1,7 @@
+type IntersectionObserverCallback = (entry: IntersectionObserverEntry) => void;
+interface IntersectionObserverManager {
+    new: (callback: IntersectionObserverCallback, options?: IntersectionObserverInit) => IntersectionObserver;
+    flushAll: () => void;
+}
+export declare const useIntersectionObservers: () => IntersectionObserverManager;
+export {};

package/types/layout.d.ts

@@ -0,0 +1,32 @@
+import type { LayoutProps, NamedLayoutProps } from './types';
+export interface LayoutDefinition<Component> {
+    component: Component;
+    props: Record<string, unknown>;
+    name?: string;
+}
+export type LayoutCallbackReturn<C> = C | [C, Record<string, unknown>?] | C[] | (C | [C, Record<string, unknown>?])[] | {
+    component: C;
+    props?: Record<string, unknown>;
+} | Record<string, C | [C, Record<string, unknown>?] | {
+    component: C;
+    props?: Record<string, unknown>;
+}> | Partial<LayoutProps>;
+export interface LayoutPropsStore {
+    set(props: Partial<LayoutProps>): void;
+    setFor<K extends keyof NamedLayoutProps>(name: K, props: Partial<NamedLayoutProps[K]>): void;
+    get(): {
+        shared: Record<string, unknown>;
+        named: Record<string, Record<string, unknown>>;
+    };
+    reset(): void;
+    subscribe(callback: () => void): () => void;
+}
+export declare function createLayoutPropsStore(): LayoutPropsStore;
+type ComponentCheck<T> = (value: unknown) => value is T;
+export declare function isPropsObject<T>(value: unknown, isComponent: ComponentCheck<T>): boolean;
+export declare function isPropsObjectOrCallback<T>(value: unknown, isComponent: ComponentCheck<T>): boolean;
+/**
+ * Normalizes layout definitions into a consistent structure.
+ */
+export declare function normalizeLayouts<T>(layout: unknown, isComponent: ComponentCheck<T>, isRenderFunction?: (value: unknown) => boolean): LayoutDefinition<T>[];
+export {};

package/types/navigationEvents.d.ts

@@ -0,0 +1,15 @@
+type MouseNavigationEvent = Pick<MouseEvent, 'altKey' | 'ctrlKey' | 'shiftKey' | 'metaKey' | 'button' | 'currentTarget' | 'defaultPrevented' | 'target'>;
+type KeyboardNavigationEvent = Pick<KeyboardEvent, 'currentTarget' | 'defaultPrevented' | 'key' | 'target'>;
+/**
+ * Determine if this mouse event should be intercepted for navigation purposes.
+ * Links with modifier keys or non-left clicks should not be intercepted.
+ * Content editable elements and prevented events are ignored.
+ */
+export declare function shouldIntercept(event: MouseNavigationEvent): boolean;
+/**
+ * Determine if this keyboard event should trigger a navigation request.
+ * Enter triggers navigation for both links and buttons currently.
+ * Space only triggers navigation for buttons specifically.
+ */
+export declare function shouldNavigate(event: KeyboardNavigationEvent): boolean;
+export {};

package/types/objectUtils.d.ts

@@ -1 +1,2 @@
-export declare const objectsAreEqual: <T>(obj1: T, obj2: T, excludeKeys: { [K in keyof T]: K; }[keyof T][]) => boolean;
+export declare const stripTopLevelUndefined: <T extends Record<string, unknown>>(obj: T) => T;
+export declare const objectsAreEqual: <T extends Record<string, any>>(obj1: T, obj2: T, excludeKeys: { [K in keyof T]: K; }[keyof T][]) => boolean;