@inertiajs/svelte 2.3.16 → 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.16",
+  "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": {
@@ -19,7 +19,8 @@
   "files": [
     "dist",
     "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
+    "!dist/**/*.spec.*",
+    "resources"
   ],
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -35,27 +36,27 @@
     }
   },
   "devDependencies": {
-    "@sveltejs/adapter-auto": "^3.3.1",
-    "@sveltejs/kit": "^2.52.2",
+    "@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.5.4",
+    "es-check": "9.5.3",
     "publint": "^0.3.17",
-    "svelte": "^4.2.20",
-    "svelte-check": "^4.3.6",
+    "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.16"
+    "@inertiajs/core": "3.0.0-beta.1"
   },
   "scripts": {
     "build": "pnpm package && svelte-check --tsconfig ./tsconfig.json && publint",

package/resources/boost/guidelines/core.blade.php

@@ -0,0 +1,3 @@
+# Inertia + Svelte
+
+- IMPORTANT: Activate `inertia-svelte-development` when working with Inertia Svelte client-side patterns.

package/resources/boost/skills/inertia-svelte-development/SKILL.blade.php

@@ -0,0 +1,372 @@
+---
+name: inertia-svelte-development
+description: "Develops Inertia.js v2 Svelte client-side applications. Activates when creating Svelte pages, forms, or navigation; using Link, Form, or router; working with deferred props, prefetching, or polling; or when user mentions Svelte with Inertia, Svelte pages, Svelte forms, or Svelte navigation."
+license: MIT
+metadata:
+  author: laravel
+---
+@php
+/** @var \Laravel\Boost\Install\GuidelineAssist $assist */
+@endphp
+# Inertia Svelte Development
+
+## When to Apply
+
+Activate this skill when:
+
+- Creating or modifying Svelte page components for Inertia
+- Working with forms in Svelte (using `<Form>` or `useForm`)
+- Implementing client-side navigation with `<Link>` or `router`
+- Using v2 features: deferred props, prefetching, WhenVisible, InfiniteScroll, once props, flash data, or polling
+- Building Svelte-specific features with the Inertia protocol
+
+## Documentation
+
+Use `search-docs` for detailed Inertia v2 Svelte patterns and documentation.
+
+## Basic Usage
+
+### Page Components Location
+
+Svelte page components should be placed in the `{{ $assist->inertia()->pagesDirectory() }}` directory.
+
+### Page Component Structure
+
+@boostsnippet("Basic Svelte Page Component", "svelte")
+<script>
+export let users
+</script>
+
+<div>
+    <h1>Users</h1>
+    <ul>
+        {#each users as user (user.id)}
+            <li>{user.name}</li>
+        {/each}
+    </ul>
+</div>
+@endboostsnippet
+
+## Client-Side Navigation
+
+### Basic Link Component
+
+Use `<Link>` for client-side navigation instead of traditional `<a>` tags:
+
+@boostsnippet("Inertia Svelte Navigation", "svelte")
+<script>
+import { Link } from '@inertiajs/svelte'
+</script>
+
+<Link href="/">Home</Link>
+<Link href="/users">Users</Link>
+<Link href={`/users/${user.id}`}>View User</Link>
+@endboostsnippet
+
+### Link With Method
+
+@boostsnippet("Link With POST Method", "svelte")
+<script>
+import { Link } from '@inertiajs/svelte'
+</script>
+
+<Link href="/logout" method="post">Logout</Link>
+@endboostsnippet
+
+### Prefetching
+
+Prefetch pages to improve perceived performance:
+
+@boostsnippet("Prefetch on Hover", "svelte")
+<script>
+import { Link } from '@inertiajs/svelte'
+</script>
+
+<Link href="/users" prefetch>Users</Link>
+@endboostsnippet
+
+### Programmatic Navigation
+
+@boostsnippet("Router Visit", "svelte")
+<script>
+import { router } from '@inertiajs/svelte'
+
+function handleClick() {
+    router.visit('/users')
+}
+
+// Or with options
+function createUser() {
+    router.visit('/users', {
+        method: 'post',
+        data: { name: 'John' },
+        onSuccess: () => console.log('Success!'),
+    })
+}
+</script>
+@endboostsnippet
+
+## Form Handling
+
+@if($assist->inertia()->hasFormComponent())
+### Form Component (Recommended)
+
+The recommended way to build forms is with the `<Form>` component:
+
+@boostsnippet("Form Component Example", "svelte")
+<script>
+import { Form } from '@inertiajs/svelte'
+</script>
+
+<Form action="/users" method="post" let:errors let:processing let:wasSuccessful>
+    <input type="text" name="name" />
+    {#if errors.name}
+        <div>{errors.name}</div>
+    {/if}
+
+    <input type="email" name="email" />
+    {#if errors.email}
+        <div>{errors.email}</div>
+    {/if}
+
+    <button type="submit" disabled={processing}>
+        {processing ? 'Creating...' : 'Create User'}
+    </button>
+
+    {#if wasSuccessful}
+        <div>User created!</div>
+    {/if}
+</Form>
+@endboostsnippet
+
+### Form Component With All Props
+
+@boostsnippet("Form Component Full Example", "svelte")
+<script>
+import { Form } from '@inertiajs/svelte'
+</script>
+
+<Form
+    action="/users"
+    method="post"
+    let:errors
+    let:hasErrors
+    let:processing
+    let:progress
+    let:wasSuccessful
+    let:recentlySuccessful
+    let:clearErrors
+    let:resetAndClearErrors
+    let:defaults
+    let:isDirty
+    let:reset
+    let:submit
+>
+    <input type="text" name="name" value={defaults.name} />
+    {#if errors.name}
+        <div>{errors.name}</div>
+    {/if}
+
+    <button type="submit" disabled={processing}>
+        {processing ? 'Saving...' : 'Save'}
+    </button>
+
+    {#if progress}
+        <progress value={progress.percentage} max="100">
+            {progress.percentage}%
+        </progress>
+    {/if}
+
+    {#if wasSuccessful}
+        <div>Saved!</div>
+    {/if}
+</Form>
+@endboostsnippet
+
+@if($assist->inertia()->hasFormComponentResets())
+### Form Component Reset Props
+
+The `<Form>` component supports automatic resetting:
+
+- `resetOnError` - Reset form data when the request fails
+- `resetOnSuccess` - Reset form data when the request succeeds
+- `setDefaultsOnSuccess` - Update default values on success
+
+Use the `search-docs` tool with a query of `form component resetting` for detailed guidance.
+
+@boostsnippet("Form With Reset Props", "svelte")
+<script>
+import { Form } from '@inertiajs/svelte'
+</script>
+
+<Form
+    action="/users"
+    method="post"
+    resetOnSuccess
+    setDefaultsOnSuccess
+    let:errors
+    let:processing
+    let:wasSuccessful
+>
+    <input type="text" name="name" />
+    {#if errors.name}
+        <div>{errors.name}</div>
+    {/if}
+
+    <button type="submit" disabled={processing}>
+        Submit
+    </button>
+</Form>
+@endboostsnippet
+@else
+Note: This version of Inertia does not support `resetOnError`, `resetOnSuccess`, or `setDefaultsOnSuccess` on the `<Form>` component. Using these props will cause errors. Upgrade to Inertia v2.2.0+ to use these features.
+@endif
+
+Forms can also be built using the `useForm` hook for more programmatic control. Use the `search-docs` tool with a query of `useForm helper` for guidance.
+
+@endif
+
+### `useForm` Hook
+
+@if($assist->inertia()->hasFormComponent() === false)
+For Inertia v2.0.x: Build forms using the `useForm` hook as the `<Form>` component is not available until v2.1.0+.
+@else
+For more programmatic control or to follow existing conventions, use the `useForm` hook:
+@endif
+
+@boostsnippet("useForm Example", "svelte")
+<script>
+import { useForm } from '@inertiajs/svelte'
+
+const form = useForm({
+    name: '',
+    email: '',
+    password: '',
+})
+
+function submit() {
+    $form.post('/users', {
+        onSuccess: () => $form.reset('password'),
+    })
+}
+</script>
+
+<form on:submit|preventDefault={submit}>
+    <input type="text" bind:value={$form.name} />
+    {#if $form.errors.name}
+        <div>{$form.errors.name}</div>
+    {/if}
+
+    <input type="email" bind:value={$form.email} />
+    {#if $form.errors.email}
+        <div>{$form.errors.email}</div>
+    {/if}
+
+    <input type="password" bind:value={$form.password} />
+    {#if $form.errors.password}
+        <div>{$form.errors.password}</div>
+    {/if}
+
+    <button type="submit" disabled={$form.processing}>
+        Create User
+    </button>
+</form>
+@endboostsnippet
+
+## Inertia v2 Features
+
+### Deferred Props
+
+Use deferred props to load data after initial page render:
+
+@boostsnippet("Deferred Props with Empty State", "svelte")
+<script>
+export let users
+</script>
+
+<div>
+    <h1>Users</h1>
+    {#if !users}
+        <div class="animate-pulse">
+            <div class="h-4 bg-gray-200 rounded w-3/4 mb-2"></div>
+            <div class="h-4 bg-gray-200 rounded w-1/2"></div>
+        </div>
+    {:else}
+        <ul>
+            {#each users as user (user.id)}
+                <li>{user.name}</li>
+            {/each}
+        </ul>
+    {/if}
+</div>
+@endboostsnippet
+
+### Polling
+
+Automatically refresh data at intervals:
+
+@boostsnippet("Polling Example", "svelte")
+<script>
+import { router } from '@inertiajs/svelte'
+import { onMount, onDestroy } from 'svelte'
+
+export let stats
+
+let interval
+
+onMount(() => {
+    interval = setInterval(() => {
+        router.reload({ only: ['stats'] })
+    }, 5000) // Poll every 5 seconds
+})
+
+onDestroy(() => {
+    clearInterval(interval)
+})
+</script>
+
+<div>
+    <h1>Dashboard</h1>
+    <div>Active Users: {stats.activeUsers}</div>
+</div>
+@endboostsnippet
+
+### WhenVisible
+
+Lazy-load a prop when an element scrolls into view. Useful for deferring expensive data that sits below the fold:
+
+@boostsnippet("WhenVisible Example", "svelte")
+<script>
+import { WhenVisible } from '@inertiajs/svelte'
+
+export let stats
+</script>
+
+<div>
+    <h1>Dashboard</h1>
+
+    <!-- stats prop is loaded only when this section scrolls into view -->
+    <WhenVisible data="stats" buffer={200}>
+        <div>
+            <p>Total Users: {stats.total_users}</p>
+            <p>Revenue: {stats.revenue}</p>
+        </div>
+
+        <svelte:fragment slot="fallback">
+            <div class="animate-pulse">Loading stats...</div>
+        </svelte:fragment>
+    </WhenVisible>
+</div>
+@endboostsnippet
+
+## Server-Side Patterns
+
+Server-side patterns (Inertia::render, props, middleware) are covered in inertia-laravel guidelines.
+
+## Common Pitfalls
+
+- Using traditional `<a>` links instead of Inertia's `<Link>` component (breaks SPA behavior)
+- Forgetting to add loading states (skeleton screens) when using deferred props
+- Not handling the `undefined` state of deferred props before data loads
+- Using `<form>` without preventing default submission (use `<Form>` component or `on:submit|preventDefault`)
+- Forgetting to check if `<Form>` component is available in your Inertia version

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>>;