@signaldb/svelte 2.0.0-beta.6 → 2.0.0-beta.7

package/dist/base/core/src/utils/match.d.ts

@@ -0,0 +1,12 @@
+import type Selector from '../types/Selector';
+type BaseItem = Record<string, any>;
+/**
+ * Tests whether a given item matches a specified selector.
+ * Uses the `mingo` library to evaluate the query.
+ * @template T - The type of the item being tested.
+ * @param item - The item to test against the selector.
+ * @param selector - The query selector used to match the item.
+ * @returns A boolean indicating whether the item matches the selector.
+ */
+export default function match<T extends BaseItem = BaseItem>(item: T, selector: Selector<T>): boolean;
+export {};

package/dist/base/core/src/utils/match.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = match;
+const mingo_1 = require("mingo");
+/**
+ * Tests whether a given item matches a specified selector.
+ * Uses the `mingo` library to evaluate the query.
+ * @template T - The type of the item being tested.
+ * @param item - The item to test against the selector.
+ * @param selector - The query selector used to match the item.
+ * @returns A boolean indicating whether the item matches the selector.
+ */
+function match(item, selector) {
+    const query = new mingo_1.Query(selector);
+    return query.test(item);
+}

package/dist/base/core/src/utils/modify.d.ts

@@ -0,0 +1,14 @@
+import type Modifier from '../types/Modifier';
+/**
+ * Applies a modifier to an object and returns a new modified object.
+ * @template T - The type of the object to be modified.
+ * @param item - The object to be modified.
+ * @param modifier - The modifier to apply. This can be any transformation logic.
+ * @returns - Returns a new object with the modifications applied.
+ * @example
+ * const item = { a: 1, b: 2 }
+ * const modifier = { $set: { b: 3, c: 4 } }
+ * const result = modify(item, modifier)
+ * // result: { a: 1, b: 3, c: 4 }
+ */
+export default function modify<T extends Record<string, any>>(item: T, modifier: Modifier): T;

package/dist/base/core/src/utils/modify.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = modify;
+const mingo_1 = require("mingo");
+const deepClone_1 = __importDefault(require("./deepClone"));
+/**
+ * Applies a modifier to an object and returns a new modified object.
+ * @template T - The type of the object to be modified.
+ * @param item - The object to be modified.
+ * @param modifier - The modifier to apply. This can be any transformation logic.
+ * @returns - Returns a new object with the modifications applied.
+ * @example
+ * const item = { a: 1, b: 2 }
+ * const modifier = { $set: { b: 3, c: 4 } }
+ * const result = modify(item, modifier)
+ * // result: { a: 1, b: 3, c: 4 }
+ */
+function modify(item, modifier) {
+    const hasOperators = Object.keys(modifier).some(key => key.startsWith('$'));
+    if (!hasOperators)
+        return modifier;
+    const clonedItem = (0, deepClone_1.default)(item);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    (0, mingo_1.update)(clonedItem, modifier);
+    return clonedItem;
+}

package/dist/base/core/src/utils/project.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Projects the fields of an object based on a specified fields configuration.
+ * Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+ * with the desired fields included or excluded, based on the configuration.
+ * @template T - The type of the object being projected.
+ * @param item - The original object to project fields from.
+ * @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+ *   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+ * @returns A new object with the specified fields included or excluded.
+ *   - If all fields are set to `0`, the excluded fields are removed from the result.
+ *   - If fields are set to `1`, only the included fields are retained.
+ */
+export default function project<T extends Record<string, any>>(item: T, fields: {
+    [P in keyof T]?: 0 | 1;
+} & Record<string, 0 | 1>): T;

package/dist/base/core/src/utils/project.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = project;
+const get_1 = __importDefault(require("./get"));
+const set_1 = __importDefault(require("./set"));
+/**
+ * Projects the fields of an object based on a specified fields configuration.
+ * Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+ * with the desired fields included or excluded, based on the configuration.
+ * @template T - The type of the object being projected.
+ * @param item - The original object to project fields from.
+ * @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+ *   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+ * @returns A new object with the specified fields included or excluded.
+ *   - If all fields are set to `0`, the excluded fields are removed from the result.
+ *   - If fields are set to `1`, only the included fields are retained.
+ */
+function project(item, fields) {
+    const allFieldsDeactivated = Object.values(fields).every(value => value === 0);
+    if (allFieldsDeactivated) {
+        const result = { ...item };
+        Object.keys(fields).forEach((key) => {
+            const fieldValue = (0, get_1.default)(item, key);
+            if (fieldValue === undefined)
+                return;
+            (0, set_1.default)(result, key, undefined, true);
+        });
+        return result;
+    }
+    const result = {};
+    Object.entries(fields).forEach(([key, value]) => {
+        const fieldValue = (0, get_1.default)(item, key);
+        if (fieldValue === undefined)
+            return;
+        if (fieldValue == null && value !== 1)
+            return;
+        (0, set_1.default)(result, key, value === 1 ? fieldValue : undefined);
+    });
+    return result;
+}

package/dist/base/core/src/utils/queryId.d.ts

@@ -0,0 +1,9 @@
+import type { QueryOptions } from '../DataAdapter';
+import type Selector from '../types/Selector';
+/**
+ * Generates a unique identifier for a query based on its selector and options.
+ * @param selector - The selector object.
+ * @param options - The query options object (optional).
+ * @returns A unique identifier string for the query.
+ */
+export default function queryId(selector: Selector<any>, options?: QueryOptions<any>): string;

package/dist/base/core/src/utils/queryId.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = queryId;
+/**
+ * Returns true when `options` is effectively "empty" for the purpose of queryId generation.
+ * Treats `undefined`/`null` as empty, and only considers plain objects with zero own enumerable keys as empty.
+ * Arrays and non-object values are not considered empty.
+ * @param options - Query options to test.
+ * @returns `true` if `options` is `null`/`undefined` or a plain object with no own keys; otherwise `false`.
+ */
+function isEmptyOptions(options) {
+    if (options == null)
+        return true;
+    if (typeof options !== 'object')
+        return false;
+    if (Array.isArray(options))
+        return false;
+    return Object.keys(options).length === 0;
+}
+/**
+ * Generates a unique identifier for a query based on its selector and options.
+ * @param selector - The selector object.
+ * @param options - The query options object (optional).
+ * @returns A unique identifier string for the query.
+ */
+function queryId(selector, options) {
+    const selectorId = JSON.stringify(selector);
+    const optionsId = isEmptyOptions(options) ? -1 : JSON.stringify(options);
+    return `${selectorId}:${optionsId}`;
+}

package/dist/base/core/src/utils/randomId.d.ts

@@ -0,0 +1,7 @@
+/**
+ * creates a random id
+ * @returns a random string of 16 characters
+ * @example
+ * randomId() // '1234567890abcdef'
+ */
+export default function randomId(): string;

package/dist/base/core/src/utils/randomId.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = randomId;
+/**
+ * creates a random id
+ * @returns a random string of 16 characters
+ * @example
+ * randomId() // '1234567890abcdef'
+ */
+function randomId() {
+    return Array.from({ length: 16 }, () => 'abcdefghijklmnopqrstuvwxyz0123456789'[Math.floor(Math.random() * 36)]).join('');
+}

package/dist/base/core/src/utils/reactiveOrAsync.d.ts

@@ -0,0 +1,59 @@
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * Options that control execution mode (and potential future mode-specific behavior).
+ * Keep this minimal; you can extend it later (e.g. signal, timeoutMs, debugLabel).
+ */
+export type ModeOptions = {
+    async?: boolean;
+};
+/**
+ * A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+ *
+ * Usage:
+ *   const doc = yield* unwrap(Collection.findOne(...))
+ *   const list = yield* unwrap(Collection.find(...).fetch())
+ *
+ * Runtime note:
+ *   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+ *   value that the runner feeds back via `.next(...)`.
+ * @param value The value (or Promise of a value) to yield to the runner.
+ * @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+ */
+export declare function unwrap<T>(value: MaybePromise<T>): Generator<MaybePromise<T>, T, T>;
+/**
+ * Generator shape used by the factory.
+ *
+ * `TThis` is the type of `this` inside the generator.
+ * `Args` are the method parameters (excluding the mode flag).
+ * `TReturn` is the final return value of the workflow.
+ * `TNext` is the type that is yielded/awaited and fed back via `.next(...)`.
+ *
+ * Note:
+ * - For best inference at yield sites, prefer `yield* unwrap(expr)` for maybe-async expressions.
+ */
+export type ReactiveOrAsyncGen<TThis, Arguments extends any[], TReturn, TNext> = (this: TThis, a: boolean, ...args: Arguments) => Generator<MaybePromise<TNext>, TReturn, TNext>;
+/**
+ * The method type produced from the generator signature.
+ * Adds overloads so that `{ async: true }` yields a `Promise<...>` return type.
+ */
+export type ReactiveOrAsyncMethod<TThis, P extends any[], R, N> = {
+    (this: TThis, ...args: P): R;
+    (this: TThis, ...args: [...P, ModeOptions?]): MaybePromise<R>;
+    (this: TThis, ...args: [...P, {
+        async: true;
+    }]): Promise<R>;
+} & {
+    /** Exposes the underlying generator for composition via `yield* method.generator.call(this, a, ...)` */
+    generator: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>;
+};
+/**
+ * Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+ *
+ * Call style:
+ *   fn(a, b)                        -> sync/reactive return
+ *   await fn(a, b, { async: true }) -> async return
+ * @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+ *   any values that may be Promises.
+ * @returns A callable method with overloads plus a `.generator` property for composition.
+ */
+export default function reactiveOrAsync<TThis, P extends any[], R, N>(gen: (this: TThis, a: boolean, ...args: P) => Generator<MaybePromise<N>, R, N>): ReactiveOrAsyncMethod<TThis, P, R, N>;

package/dist/base/core/src/utils/reactiveOrAsync.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrap = unwrap;
+exports.default = reactiveOrAsync;
+/**
+ * A generator helper that makes TypeScript infer the “synchronous value type” for maybe-async expressions.
+ *
+ * Usage:
+ *   const doc = yield* unwrap(Collection.findOne(...))
+ *   const list = yield* unwrap(Collection.find(...).fetch())
+ *
+ * Runtime note:
+ *   This does not “unwrap” Promises by itself. It yields the value/Promise to the runner and returns the
+ *   value that the runner feeds back via `.next(...)`.
+ * @param value The value (or Promise of a value) to yield to the runner.
+ * @returns A generator that yields `value` and resolves to the runner-supplied unwrapped `T`.
+ */
+function unwrap(value) {
+    return (function* () {
+        return yield value;
+    })();
+}
+/**
+ * Internal: checks for thenables (Promise-like).
+ * @param value The value to test.
+ * @returns `true` if `value` looks like a Promise/thenable.
+ */
+function isThenable(value) {
+    return typeof value === 'object' && value !== null && typeof value.then === 'function';
+}
+/**
+ * Internal runner: executes a generator either synchronously (reactive) or asynchronously (imperative).
+ *
+ * - In sync mode, yielding a Promise is a programming error and throws.
+ * - In async mode, yielded Promises are awaited.
+ * @param thisArgument The `this` value to bind when invoking `gen`.
+ * @param mode Execution mode options.
+ * @param gen The generator workflow to run.
+ * @returns The workflow result (a plain value in sync mode, or a Promise in async mode).
+ */
+function runReactiveOrAsync(thisArgument, mode, gen) {
+    const a = !!mode?.async;
+    const it = gen.call(thisArgument, a);
+    if (!a) {
+        let step = it.next();
+        while (!step.done) {
+            const y = step.value;
+            if (isThenable(y))
+                throw new Error('Promise yielded in sync flow');
+            step = it.next(y);
+        }
+        return step.value;
+    }
+    return (async function () {
+        let step = it.next();
+        while (!step.done) {
+            const y = step.value;
+            const v = isThenable(y) ? await y : y;
+            step = it.next(v);
+        }
+        return step.value;
+    })();
+}
+/**
+ * Factory that turns a generator workflow into a callable method that can run in sync (reactive) or async mode.
+ *
+ * Call style:
+ *   fn(a, b)                        -> sync/reactive return
+ *   await fn(a, b, { async: true }) -> async return
+ * @param gen Generator workflow. Receives `(a)` which indicates async mode and should `yield`/`yield* unwrap(...)`
+ *   any values that may be Promises.
+ * @returns A callable method with overloads plus a `.generator` property for composition.
+ */
+function reactiveOrAsync(gen) {
+    /**
+     * The generated method wrapper.
+     * @param allArguments Method arguments, optionally ending with a `ModeOptions` object.
+     * @returns The workflow result (sync) or a Promise of the result (async).
+     */
+    function method(...allArguments) {
+        const last = allArguments.length > 0 ? allArguments.at(-1) : undefined;
+        const hasMode = typeof last === 'object'
+            && last !== null
+            && 'async' in (last);
+        const mode = hasMode ? last : undefined;
+        const parameters = (hasMode ? allArguments.slice(0, -1) : allArguments);
+        return runReactiveOrAsync(this, mode, function* (a) {
+            return yield* gen.call(this, a, ...parameters);
+        });
+    }
+    method.generator = gen;
+    return method;
+}

package/dist/base/core/src/utils/serializeValue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Serializes a value into a string representation.
+ * Handles various types, including strings, numbers, booleans, dates, and objects.
+ * Falls back to JSON stringification for unsupported types.
+ * @param value - The value to serialize.
+ *   - Strings are returned as-is.
+ *   - Numbers and booleans are converted to their string representation.
+ *   - Dates are converted to ISO string format.
+ *   - Other values are stringified using `JSON.stringify`.
+ * @returns A string representation of the value.
+ */
+export default function serializeValue(value: any): string | null;

package/dist/base/core/src/utils/serializeValue.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = serializeValue;
+/**
+ * Serializes a value into a string representation.
+ * Handles various types, including strings, numbers, booleans, dates, and objects.
+ * Falls back to JSON stringification for unsupported types.
+ * @param value - The value to serialize.
+ *   - Strings are returned as-is.
+ *   - Numbers and booleans are converted to their string representation.
+ *   - Dates are converted to ISO string format.
+ *   - Other values are stringified using `JSON.stringify`.
+ * @returns A string representation of the value.
+ */
+function serializeValue(value) {
+    if (value == null)
+        return null;
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number')
+        return value.toString();
+    if (typeof value === 'boolean')
+        return value.toString();
+    if (value instanceof Date)
+        return value.toISOString();
+    return JSON.stringify(value);
+}

package/dist/base/core/src/utils/set.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Sets a value at a specified path within an object. Creates nested structures
+ * (arrays or objects) as needed to set the value at the correct location. Supports
+ * deleting the key if the value is `undefined` and the `deleteIfUndefined` flag is set to `true`.
+ * @template T - The type of the object to modify.
+ * @template K - The type of the value to set.
+ * @param object - The object to modify. The object is mutated directly.
+ * @param path - The path (dot or bracket notation) where the value should be set.
+ * @param value - The value to set at the specified path.
+ * @param deleteIfUndefined - A boolean indicating whether to delete the key if the value is `undefined` (default: `false`).
+ * @returns The modified object.
+ */
+export default function set<T extends object, K>(object: T, path: string, value: K, deleteIfUndefined?: boolean): T;

package/dist/base/core/src/utils/set.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = set;
+/**
+ * Sets a value at a specified path within an object. Creates nested structures
+ * (arrays or objects) as needed to set the value at the correct location. Supports
+ * deleting the key if the value is `undefined` and the `deleteIfUndefined` flag is set to `true`.
+ * @template T - The type of the object to modify.
+ * @template K - The type of the value to set.
+ * @param object - The object to modify. The object is mutated directly.
+ * @param path - The path (dot or bracket notation) where the value should be set.
+ * @param value - The value to set at the specified path.
+ * @param deleteIfUndefined - A boolean indicating whether to delete the key if the value is `undefined` (default: `false`).
+ * @returns The modified object.
+ */
+function set(object, path, value, deleteIfUndefined = false) {
+    if (object == null)
+        return object;
+    const segments = path.split(/[.[\]]/g);
+    if (segments[0] === '')
+        segments.shift();
+    if (segments.at(-1) === '')
+        segments.pop();
+    const apply = (node) => {
+        if (segments.length > 1) {
+            const key = segments.shift();
+            const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
+            if (node[key] === undefined) {
+                node[key] = nextIsNumber ? [] : {};
+            }
+            apply(node[key]);
+        }
+        else {
+            if (deleteIfUndefined && value === undefined) {
+                delete node[segments[0]];
+                return;
+            }
+            node[segments[0]] = value;
+        }
+    };
+    apply(object);
+    return object;
+}

package/dist/base/core/src/utils/sortItems.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Sorts an array of items based on multiple fields and their specified sort order.
+ * Uses the `fast-sort` library for efficient sorting.
+ * @template T - The type of the items in the array.
+ * @param items - The array of items to be sorted.
+ * @param sortFields - An object defining the sort order for each field.
+ *   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+ * @returns A new array of items sorted based on the specified fields and their order.
+ */
+export default function sortItems<T extends Record<string, any>>(items: T[], sortFields: {
+    [P in keyof T]?: -1 | 1;
+} & Record<string, -1 | 1>): T[];

package/dist/base/core/src/utils/sortItems.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sortItems;
+const fast_sort_1 = require("fast-sort");
+const get_1 = __importDefault(require("./get"));
+/**
+ * Sorts an array of items based on multiple fields and their specified sort order.
+ * Uses the `fast-sort` library for efficient sorting.
+ * @template T - The type of the items in the array.
+ * @param items - The array of items to be sorted.
+ * @param sortFields - An object defining the sort order for each field.
+ *   - Keys are the field names, and values are either `1` (ascending) or `-1` (descending).
+ * @returns A new array of items sorted based on the specified fields and their order.
+ */
+function sortItems(items, sortFields) {
+    return (0, fast_sort_1.sort)(items).by(Object.entries(sortFields).map(([key, value]) => {
+        const order = value === 1 ? 'asc' : 'desc';
+        return { [order]: (i) => (0, get_1.default)(i, key) };
+    }));
+}

package/dist/base/core/src/utils/uniqueBy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Filters an array to ensure unique values based on a specified key or transformation function.
+ * @template T - The type of the elements in the array.
+ * @param array - The array to filter for unique values.
+ * @param fn - A key or transformation function to determine uniqueness.
+ *   - If a key is provided, it will use the corresponding property of each element for uniqueness.
+ *   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
+ * @returns A new array containing only unique elements based on the specified key or transformation.
+ */
+export default function uniqueBy<T>(array: T[], fn: keyof T | ((item: T) => any)): T[];

package/dist/base/core/src/utils/uniqueBy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = uniqueBy;
+/**
+ * Filters an array to ensure unique values based on a specified key or transformation function.
+ * @template T - The type of the elements in the array.
+ * @param array - The array to filter for unique values.
+ * @param fn - A key or transformation function to determine uniqueness.
+ *   - If a key is provided, it will use the corresponding property of each element for uniqueness.
+ *   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
+ * @returns A new array containing only unique elements based on the specified key or transformation.
+ */
+function uniqueBy(array, fn) {
+    const set = new Set();
+    return array.filter((element) => {
+        const value = typeof fn === 'function' ? fn(element) : element[fn];
+        return !set.has(value) && set.add(value);
+    });
+}

package/dist/reactivity-adapters/svelte/index.svelte.d.ts

@@ -0,0 +1,10 @@
+export declare class SvelteDependency {
+    #private;
+    constructor();
+    depend(): void;
+    notify(): void;
+    onDispose(callback: () => void): void;
+    dispose(): void;
+}
+declare const svelteReactivityAdapter: import("@signaldb/core").ReactivityAdapter<SvelteDependency>;
+export default svelteReactivityAdapter;

package/dist/reactivity-adapters/svelte/index.svelte.js

@@ -0,0 +1,36 @@
+import { createSubscriber } from 'svelte/reactivity';
+import { createReactivityAdapter } from '@signaldb/core';
+export class SvelteDependency {
+    #subscribe;
+    #update;
+    #onDisposeCallbacks;
+    constructor() {
+        this.#onDisposeCallbacks = [];
+        this.#subscribe = createSubscriber((update) => {
+            this.#update = update;
+            return () => this.dispose();
+        });
+    }
+    depend() {
+        this.#subscribe();
+    }
+    notify() {
+        // The #update can potentially be undefined because it only becomes
+        // available after #subscribe is called for the first time within a scope.
+        this.#update?.();
+    }
+    onDispose(callback) {
+        this.#onDisposeCallbacks.push(callback);
+    }
+    dispose() {
+        this.#onDisposeCallbacks.forEach(callback => callback());
+    }
+}
+const svelteReactivityAdapter = createReactivityAdapter({
+    create: () => new SvelteDependency(),
+    isInScope: () => $effect.tracking(),
+    onDispose(callback, svelteDependency) {
+        svelteDependency.onDispose(callback);
+    },
+});
+export default svelteReactivityAdapter;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@signaldb/svelte",
   "type": "module",
-  "version": "2.0.0-beta.6",
+  "version": "2.0.0-beta.7",
   "scripts": {
     "build": "tsc -d --noEmit false",
     "analyze-bundle": "bundle-analyzer ./dist --upload-token=$BUNDLE_ANALYZER_UPLOAD_TOKEN --bundle-name=@signaldb/svelte",
@@ -45,7 +45,7 @@
     "svelte": "^5.7.0"
   },
   "devDependencies": {
-    "@sveltejs/vite-plugin-svelte": "6.2.4",
-    "svelte": "5.49.1"
+    "@sveltejs/vite-plugin-svelte": "7.1.2",
+    "svelte": "5.56.1"
   }
 }