@inertiajs/svelte 2.3.17 → 3.0.0-beta.1

package/dist/useHttp.svelte.js

@@ -0,0 +1,154 @@
+import { hasFiles, http, HttpCancelledError, HttpResponseError, mergeDataIntoQueryString, objectToFormData, UseFormUtils, } from '@inertiajs/core';
+import { toSimpleValidationErrors } from 'laravel-precognition';
+import { cloneDeep } from 'lodash-es';
+import useFormState, {} from './useFormState.svelte';
+export default function useHttp(...args) {
+    const { rememberKey, data, precognitionEndpoint } = UseFormUtils.parseUseFormArguments(...args);
+    let abortController = null;
+    let pendingOptimisticCallback = null;
+    const { form: baseForm, setDefaults, getTransform, getPrecognitionEndpoint, setFormState, markAsSuccessful, wasDefaultsCalledInOnSuccess, resetDefaultsCalledInOnSuccess, setRememberExcludeKeys, resetBeforeSubmit, finishProcessing, withAllErrors, } = useFormState({
+        data,
+        rememberKey,
+        precognitionEndpoint,
+    });
+    const formWithPrecognition = () => baseForm;
+    setFormState('response', null);
+    const submit = async (method, url, options) => {
+        const onBefore = options.onBefore?.();
+        if (onBefore === false) {
+            return Promise.reject(new Error('Request cancelled by onBefore'));
+        }
+        resetDefaultsCalledInOnSuccess();
+        resetBeforeSubmit();
+        abortController = new AbortController();
+        const cancelToken = {
+            cancel: () => abortController?.abort(),
+        };
+        options.onCancelToken?.(cancelToken);
+        options.optimistic = options.optimistic ?? pendingOptimisticCallback ?? undefined;
+        pendingOptimisticCallback = null;
+        let snapshot;
+        if (options.optimistic) {
+            snapshot = cloneDeep(form.data());
+            const optimisticData = options.optimistic(cloneDeep(snapshot));
+            Object.keys(optimisticData).forEach((key) => {
+                ;
+                baseForm[key] = optimisticData[key];
+            });
+        }
+        setFormState('processing', true);
+        options.onStart?.();
+        const transformedData = getTransform()(form.data());
+        const useFormData = hasFiles(transformedData);
+        let requestUrl = url;
+        let requestData;
+        let contentType;
+        if (method === 'get') {
+            const [urlWithParams] = mergeDataIntoQueryString(method, url, transformedData);
+            requestUrl = urlWithParams;
+        }
+        else {
+            if (useFormData) {
+                requestData = objectToFormData(transformedData);
+            }
+            else {
+                requestData = JSON.stringify(transformedData);
+                contentType = 'application/json';
+            }
+        }
+        try {
+            const response = await http.getClient().request({
+                method,
+                url: requestUrl,
+                data: requestData,
+                headers: {
+                    Accept: 'application/json',
+                    ...(contentType ? { 'Content-Type': contentType } : {}),
+                    ...options.headers,
+                },
+                signal: abortController.signal,
+                onUploadProgress: (event) => {
+                    setFormState('progress', event);
+                    options.onProgress?.(event);
+                },
+            });
+            const responseData = JSON.parse(response.data);
+            if (response.status >= 200 && response.status < 300) {
+                markAsSuccessful();
+                setFormState('response', responseData);
+                options.onSuccess?.(responseData);
+                if (!wasDefaultsCalledInOnSuccess()) {
+                    setDefaults(cloneDeep(form.data()));
+                }
+                setFormState('isDirty', false);
+                return responseData;
+            }
+            throw new HttpResponseError(`Request failed with status ${response.status}`, response, url);
+        }
+        catch (error) {
+            if (snapshot) {
+                Object.keys(snapshot).forEach((key) => {
+                    ;
+                    baseForm[key] = snapshot[key];
+                });
+            }
+            if (error instanceof HttpResponseError) {
+                if (error.response.status === 422) {
+                    const responseData = JSON.parse(error.response.data);
+                    const validationErrors = responseData.errors || {};
+                    const processedErrors = (withAllErrors.enabled() ? validationErrors : toSimpleValidationErrors(validationErrors));
+                    form.clearErrors().setError(processedErrors);
+                    options.onError?.(processedErrors);
+                }
+                throw error;
+            }
+            if (error instanceof HttpCancelledError || (error instanceof Error && error.name === 'AbortError')) {
+                options.onCancel?.();
+                throw new HttpCancelledError('Request was cancelled', url);
+            }
+            throw error;
+        }
+        finally {
+            finishProcessing();
+            abortController = null;
+            options.onFinish?.();
+        }
+    };
+    const cancel = () => {
+        abortController?.abort();
+    };
+    const createSubmitMethod = (method) => async (url, options = {}) => {
+        return submit(method, url, options);
+    };
+    Object.assign(baseForm, {
+        submit(...args) {
+            const parsed = UseFormUtils.parseSubmitArguments(args, getPrecognitionEndpoint());
+            return submit(parsed.method, parsed.url, parsed.options);
+        },
+        get: createSubmitMethod('get'),
+        post: createSubmitMethod('post'),
+        put: createSubmitMethod('put'),
+        patch: createSubmitMethod('patch'),
+        delete: createSubmitMethod('delete'),
+        cancel,
+        dontRemember(...keys) {
+            setRememberExcludeKeys(keys);
+            return form;
+        },
+        optimistic(callback) {
+            pendingOptimisticCallback = callback;
+            return form;
+        },
+        withAllErrors() {
+            withAllErrors.enable();
+            return form;
+        },
+    });
+    const form = baseForm;
+    const originalWithPrecognition = formWithPrecognition().withPrecognition;
+    form.withPrecognition = (...args) => {
+        originalWithPrecognition(...args);
+        return form;
+    };
+    return getPrecognitionEndpoint() ? form : form;
+}

package/dist/usePrefetch.svelte.d.ts

@@ -0,0 +1,7 @@
+import { type VisitOptions } from '@inertiajs/core';
+export default function usePrefetch(options?: VisitOptions): {
+    readonly isPrefetched: boolean;
+    readonly isPrefetching: boolean;
+    readonly lastUpdatedAt: number | null;
+    flush(): void;
+};

package/dist/{usePrefetch.js → usePrefetch.svelte.js}

@@ -1,27 +1,26 @@
 import { router } from '@inertiajs/core';
 import { onDestroy, onMount } from 'svelte';
-import { readonly, writable } from 'svelte/store';
 export default function usePrefetch(options = {}) {
-    const isPrefetched = writable(false);
-    const isPrefetching = writable(false);
-    const lastUpdatedAt = writable(null);
+    let isPrefetched = $state(false);
+    let isPrefetching = $state(false);
+    let lastUpdatedAt = $state(null);
     const cached = typeof window === 'undefined' ? null : router.getCached(window.location.pathname, options);
     const inFlight = typeof window === 'undefined' ? null : router.getPrefetching(window.location.pathname, options);
-    isPrefetched.set(cached !== null);
-    isPrefetching.set(inFlight !== null);
-    lastUpdatedAt.set(cached?.staleTimestamp || null);
+    isPrefetched = cached !== null;
+    isPrefetching = inFlight !== null;
+    lastUpdatedAt = cached?.staleTimestamp || null;
     let removePrefetchedListener;
     let removePrefetchingListener;
     onMount(() => {
         removePrefetchingListener = router.on('prefetching', ({ detail }) => {
             if (detail.visit.url.pathname === window.location.pathname) {
-                isPrefetching.set(true);
+                isPrefetching = true;
             }
         });
         removePrefetchedListener = router.on('prefetched', ({ detail }) => {
             if (detail.visit.url.pathname === window.location.pathname) {
-                isPrefetched.set(true);
-                isPrefetching.set(false);
+                isPrefetched = true;
+                isPrefetching = false;
             }
         });
     });
@@ -34,9 +33,15 @@ export default function usePrefetch(options = {}) {
         }
     });
     return {
-        isPrefetched: readonly(isPrefetched),
-        isPrefetching: readonly(isPrefetching),
-        lastUpdatedAt: readonly(lastUpdatedAt),
+        get isPrefetched() {
+            return isPrefetched;
+        },
+        get isPrefetching() {
+            return isPrefetching;
+        },
+        get lastUpdatedAt() {
+            return lastUpdatedAt;
+        },
         flush() {
             router.flush(window.location.pathname, options);
         },

package/dist/useRemember.svelte.d.ts

@@ -0,0 +1 @@
+export default function useRemember<State extends object>(initialState: State, key?: string): State;

package/dist/useRemember.svelte.js

@@ -0,0 +1,10 @@
+import { router } from '@inertiajs/core';
+import { cloneDeep } from 'lodash-es';
+export default function useRemember(initialState, key) {
+    const restored = router.restore(key);
+    const state = $state(restored !== undefined ? cloneDeep(restored) : initialState);
+    $effect(() => {
+        router.remember(cloneDeep($state.snapshot(state)), key);
+    });
+    return state;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inertiajs/svelte",
-  "version": "2.3.17",
+  "version": "3.0.0-beta.1",
   "license": "MIT",
   "description": "The Svelte adapter for Inertia.js",
   "contributors": [
@@ -10,7 +10,7 @@
   "homepage": "https://inertiajs.com/",
   "repository": {
     "type": "git",
-    "url": "https://github.com/inertiajs/inertia.git",
+    "url": "git+https://github.com/inertiajs/inertia.git",
     "directory": "packages/svelte"
   },
   "bugs": {
@@ -36,27 +36,27 @@
     }
   },
   "devDependencies": {
-    "@sveltejs/adapter-auto": "^3.3.1",
+    "@sveltejs/adapter-auto": "^7.0.1",
     "@sveltejs/kit": "^2.53.2",
     "@sveltejs/package": "^2.5.7",
-    "@sveltejs/vite-plugin-svelte": "^3.1.2",
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "axios": "^1.13.5",
-    "es-check": "^9.6.1",
+    "es-check": "9.5.3",
     "publint": "^0.3.17",
-    "svelte": "^4.2.20",
-    "svelte-check": "^4.4.4",
+    "svelte": "^5.53.5",
+    "svelte-check": "^4.4.3",
     "tslib": "^2.8.1",
     "typescript": "^5.9.3",
-    "vite": "^5.4.21"
+    "vite": "^7.3.1"
   },
   "peerDependencies": {
-    "svelte": "^4.0.0 || ^5.0.0"
+    "svelte": "^5.0.0"
   },
   "dependencies": {
     "@types/lodash-es": "^4.17.12",
-    "laravel-precognition": "^1.0.2",
+    "laravel-precognition": "2.0.0-beta.2",
     "lodash-es": "^4.17.23",
-    "@inertiajs/core": "2.3.17"
+    "@inertiajs/core": "3.0.0-beta.1"
   },
   "scripts": {
     "build": "pnpm package && svelte-check --tsconfig ./tsconfig.json && publint",

package/dist/page.d.ts

@@ -1,13 +0,0 @@
-import { type Page, type PageProps, type SharedPageProps } from '@inertiajs/core';
-import { type Readable } from 'svelte/store';
-type SveltePage<TPageProps extends PageProps = PageProps> = Omit<Page<TPageProps & SharedPageProps>, 'props'> & {
-    props: Page<TPageProps & SharedPageProps>['props'] & {
-        [key: string]: any;
-    };
-};
-export declare const setPage: (this: void, value: SveltePage<PageProps>) => void;
-declare const _default: {
-    subscribe: (this: void, run: import("svelte/store").Subscriber<SveltePage<PageProps>>, invalidate?: import("svelte/store").Invalidator<SveltePage<PageProps>> | undefined) => import("svelte/store").Unsubscriber;
-};
-export default _default;
-export declare function usePage<TPageProps extends PageProps = PageProps>(): Readable<SveltePage<TPageProps>>;

package/dist/page.js

@@ -1,8 +0,0 @@
-import {} from '@inertiajs/core';
-import { derived, writable } from 'svelte/store';
-const { set, subscribe } = writable();
-export const setPage = set;
-export default { subscribe };
-export function usePage() {
-    return derived({ subscribe }, ($page) => $page);
-}

package/dist/useForm.js

@@ -1,356 +0,0 @@
-import { router, UseFormUtils } from '@inertiajs/core';
-import { createValidator, resolveName, toSimpleValidationErrors } from 'laravel-precognition';
-import { cloneDeep, get, has, isEqual, set } from 'lodash-es';
-import { get as getStore, writable } from 'svelte/store';
-import { config } from '.';
-let reservedFormKeys = null;
-let bootstrapping = false;
-function validateFormDataKeys(data) {
-    if (bootstrapping) {
-        return;
-    }
-    if (reservedFormKeys === null) {
-        bootstrapping = true;
-        const store = useForm({});
-        reservedFormKeys = new Set(Object.keys(getStore(store)));
-        bootstrapping = false;
-    }
-    const conflicts = Object.keys(data).filter((key) => reservedFormKeys.has(key));
-    if (conflicts.length > 0) {
-        console.error(`[Inertia] useForm() data contains field(s) that conflict with form properties: ${conflicts.map((k) => `"${k}"`).join(', ')}. ` +
-            `These fields will be overwritten by form methods/properties. Please rename these fields.`);
-    }
-}
-export default function useForm(...args) {
-    const parsedArgs = UseFormUtils.parseUseFormArguments(...args);
-    const { rememberKey, data: initialData } = parsedArgs;
-    let precognitionEndpoint = parsedArgs.precognitionEndpoint;
-    const data = typeof initialData === 'function' ? initialData() : initialData;
-    const restored = rememberKey
-        ? router.restore(rememberKey)
-        : null;
-    let defaults = cloneDeep(data);
-    validateFormDataKeys(defaults);
-    let cancelToken = null;
-    let recentlySuccessfulTimeoutId = null;
-    let transform = (data) => data;
-    let rememberExcludeKeys = [];
-    let defaultsCalledInOnSuccess = false;
-    let validatorRef = null;
-    let setFormState;
-    const withPrecognition = (...args) => {
-        precognitionEndpoint = UseFormUtils.createWayfinderCallback(...args);
-        const formWithPrecognition = () => getStore(store);
-        let withAllErrors = null;
-        if (!validatorRef) {
-            const validator = createValidator((client) => {
-                const { method, url } = precognitionEndpoint();
-                const form = formWithPrecognition();
-                const transformedData = cloneDeep(transform(form.data()));
-                return client[method](url, transformedData);
-            }, cloneDeep(defaults));
-            validatorRef = validator;
-            validator
-                .on('validatingChanged', () => {
-                setFormState('validating', validator.validating());
-            })
-                .on('validatedChanged', () => {
-                setFormState('__valid', validator.valid());
-            })
-                .on('touchedChanged', () => {
-                setFormState('__touched', validator.touched());
-            })
-                .on('errorsChanged', () => {
-                const validationErrors = (withAllErrors ?? config.get('form.withAllErrors'))
-                    ? validator.errors()
-                    : toSimpleValidationErrors(validator.errors());
-                setFormState('errors', {});
-                formWithPrecognition().setError(validationErrors);
-                setFormState('__valid', validator.valid());
-            });
-        }
-        const tap = (value, callback) => {
-            callback(value);
-            return value;
-        };
-        if (validatorRef) {
-            Object.assign(store, {});
-        }
-        store.update((form) => {
-            return Object.assign(store, {
-                ...form,
-                __touched: [],
-                __valid: [],
-                validating: false,
-                validator: () => validatorRef,
-                validate: (field, config) => {
-                    const form = formWithPrecognition();
-                    if (typeof field === 'object' && !('target' in field)) {
-                        config = field;
-                        field = undefined;
-                    }
-                    if (field === undefined) {
-                        validatorRef.validate(config);
-                    }
-                    else {
-                        field = resolveName(field);
-                        const transformedData = transform(form.data());
-                        validatorRef.validate(field, get(transformedData, field), config);
-                    }
-                    return form;
-                },
-                touch: (field, ...fields) => {
-                    const form = formWithPrecognition();
-                    if (Array.isArray(field)) {
-                        validatorRef?.touch(field);
-                    }
-                    else if (typeof field === 'string') {
-                        validatorRef?.touch([field, ...fields]);
-                    }
-                    else {
-                        validatorRef?.touch(field);
-                    }
-                    return form;
-                },
-                validateFiles: () => tap(formWithPrecognition(), () => validatorRef?.validateFiles()),
-                setValidationTimeout: (duration) => tap(formWithPrecognition(), () => validatorRef.setTimeout(duration)),
-                withAllErrors: () => tap(formWithPrecognition(), () => (withAllErrors = true)),
-                withoutFileValidation: () => tap(formWithPrecognition(), () => validatorRef?.withoutFileValidation()),
-                valid: (field) => formWithPrecognition().__valid.includes(field),
-                invalid: (field) => field in formWithPrecognition().errors,
-                touched: (field) => {
-                    const touched = formWithPrecognition().__touched;
-                    return typeof field === 'string' ? touched.includes(field) : touched.length > 0;
-                },
-                setErrors: (errors) => tap(formWithPrecognition(), () => {
-                    const form = formWithPrecognition();
-                    form.setError(errors);
-                }),
-                forgetError: (field) => tap(formWithPrecognition(), () => {
-                    const form = formWithPrecognition();
-                    form.clearErrors(resolveName(field));
-                }),
-            });
-        });
-        return store;
-    };
-    const store = writable({
-        ...(restored ? restored.data : data),
-        isDirty: false,
-        errors: (restored ? restored.errors : {}),
-        hasErrors: false,
-        progress: null,
-        wasSuccessful: false,
-        recentlySuccessful: false,
-        processing: false,
-        setStore(keyOrData, maybeValue = undefined) {
-            store.update((store) => {
-                return typeof keyOrData === 'string' ? set(store, keyOrData, maybeValue) : Object.assign(store, keyOrData);
-            });
-        },
-        data() {
-            return Object.keys(data).reduce((carry, key) => {
-                return set(carry, key, get(this, key));
-            }, {});
-        },
-        transform(callback) {
-            transform = callback;
-            return this;
-        },
-        defaults(fieldOrFields, maybeValue) {
-            defaultsCalledInOnSuccess = true;
-            if (typeof fieldOrFields === 'undefined') {
-                defaults = cloneDeep(this.data());
-            }
-            else {
-                defaults =
-                    typeof fieldOrFields === 'string'
-                        ? set(cloneDeep(defaults), fieldOrFields, maybeValue)
-                        : Object.assign(cloneDeep(defaults), fieldOrFields);
-            }
-            validatorRef?.defaults(defaults);
-            return this;
-        },
-        reset(...fields) {
-            const clonedData = cloneDeep(defaults);
-            if (fields.length === 0) {
-                this.setStore(clonedData);
-            }
-            else {
-                this.setStore(fields
-                    .filter((key) => has(clonedData, key))
-                    .reduce((carry, key) => {
-                    return set(carry, key, get(clonedData, key));
-                }, {}));
-            }
-            validatorRef?.reset(...fields);
-            return this;
-        },
-        setError(fieldOrFields, maybeValue) {
-            const errors = typeof fieldOrFields === 'string' ? { [fieldOrFields]: maybeValue } : fieldOrFields;
-            setFormState('errors', {
-                ...this.errors,
-                ...errors,
-            });
-            validatorRef?.setErrors(errors);
-            return this;
-        },
-        clearErrors(...fields) {
-            setFormState('errors', Object.keys(this.errors).reduce((carry, field) => ({
-                ...carry,
-                ...(fields.length > 0 && !fields.includes(field) ? { [field]: this.errors[field] } : {}),
-            }), {}));
-            if (validatorRef) {
-                if (fields.length === 0) {
-                    validatorRef.setErrors({});
-                }
-                else {
-                    fields.forEach(validatorRef.forgetError);
-                }
-            }
-            return this;
-        },
-        resetAndClearErrors(...fields) {
-            this.reset(...fields);
-            this.clearErrors(...fields);
-            return this;
-        },
-        submit(...args) {
-            const { method, url, options } = UseFormUtils.parseSubmitArguments(args, precognitionEndpoint);
-            defaultsCalledInOnSuccess = false;
-            const data = transform(this.data());
-            const _options = {
-                ...options,
-                onCancelToken: (token) => {
-                    cancelToken = token;
-                    if (options.onCancelToken) {
-                        return options.onCancelToken(token);
-                    }
-                },
-                onBefore: (visit) => {
-                    setFormState('wasSuccessful', false);
-                    setFormState('recentlySuccessful', false);
-                    if (recentlySuccessfulTimeoutId) {
-                        clearTimeout(recentlySuccessfulTimeoutId);
-                    }
-                    if (options.onBefore) {
-                        return options.onBefore(visit);
-                    }
-                },
-                onStart: (visit) => {
-                    setFormState('processing', true);
-                    if (options.onStart) {
-                        return options.onStart(visit);
-                    }
-                },
-                onProgress: (event) => {
-                    setFormState('progress', event || null);
-                    if (options.onProgress) {
-                        return options.onProgress(event);
-                    }
-                },
-                onSuccess: async (page) => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    this.clearErrors();
-                    setFormState('wasSuccessful', true);
-                    setFormState('recentlySuccessful', true);
-                    recentlySuccessfulTimeoutId = setTimeout(() => setFormState('recentlySuccessful', false), config.get('form.recentlySuccessfulDuration'));
-                    const onSuccess = options.onSuccess ? await options.onSuccess(page) : null;
-                    if (!defaultsCalledInOnSuccess) {
-                        this.defaults(cloneDeep(getStore(store).data()));
-                    }
-                    return onSuccess;
-                },
-                onError: (errors) => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    setFormState('errors', errors);
-                    validatorRef?.setErrors(errors);
-                    if (options.onError) {
-                        return options.onError(errors);
-                    }
-                },
-                onCancel: () => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    if (options.onCancel) {
-                        return options.onCancel();
-                    }
-                },
-                onFinish: (visit) => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    cancelToken = null;
-                    if (options.onFinish) {
-                        return options.onFinish(visit);
-                    }
-                },
-            };
-            if (method === 'delete') {
-                router.delete(url, { ..._options, data });
-            }
-            else {
-                router[method](url, data, _options);
-            }
-        },
-        get(url, options) {
-            this.submit('get', url, options);
-        },
-        post(url, options) {
-            this.submit('post', url, options);
-        },
-        put(url, options) {
-            this.submit('put', url, options);
-        },
-        patch(url, options) {
-            this.submit('patch', url, options);
-        },
-        delete(url, options) {
-            this.submit('delete', url, options);
-        },
-        cancel() {
-            cancelToken?.cancel();
-        },
-        __remember() {
-            const data = this.data();
-            if (rememberExcludeKeys.length > 0) {
-                const filtered = { ...data };
-                rememberExcludeKeys.forEach((k) => delete filtered[k]);
-                return { data: filtered, errors: this.errors };
-            }
-            return { data, errors: this.errors };
-        },
-        withPrecognition,
-    });
-    const dontRememberMethod = (...keys) => {
-        rememberExcludeKeys = keys;
-        return store;
-    };
-    Object.assign(store, {
-        withPrecognition,
-        dontRemember: dontRememberMethod,
-    });
-    setFormState = (key, value) => {
-        store.update((form) => ({ ...form, [key]: value }));
-    };
-    store.subscribe((form) => {
-        if (form.isDirty === isEqual(form.data(), defaults)) {
-            setFormState('isDirty', !form.isDirty);
-        }
-        const hasErrors = Object.keys(form.errors).length > 0;
-        if (form.hasErrors !== hasErrors) {
-            setFormState('hasErrors', !form.hasErrors);
-        }
-        if (rememberKey) {
-            const storedData = router.restore(rememberKey);
-            const newData = form.__remember();
-            if (!isEqual(storedData, newData)) {
-                router.remember(newData, rememberKey);
-            }
-        }
-    });
-    return precognitionEndpoint
-        ? store.withPrecognition(precognitionEndpoint)
-        : store;
-}

package/dist/usePrefetch.d.ts

@@ -1,7 +0,0 @@
-import { type VisitOptions } from '@inertiajs/core';
-export default function usePrefetch(options?: VisitOptions): {
-    isPrefetched: import("svelte/store").Readable<boolean>;
-    isPrefetching: import("svelte/store").Readable<boolean>;
-    lastUpdatedAt: import("svelte/store").Readable<number | null>;
-    flush(): void;
-};

package/dist/useRemember.d.ts

@@ -1 +0,0 @@
-export default function useRemember<State>(initialState: State, key?: string): import("svelte/store").Writable<State>;