svstate 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createSvState, type EffectContext, type Snapshot, type SnapshotFunction, type SvStateOptions, type Validator } from './state.svelte';
+export { arrayValidator, dateValidator, numberValidator, stringValidator } from './validators';

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringValidator = exports.numberValidator = exports.dateValidator = exports.arrayValidator = exports.createSvState = void 0;
+var state_svelte_1 = require("./state.svelte");
+Object.defineProperty(exports, "createSvState", { enumerable: true, get: function () { return state_svelte_1.createSvState; } });
+var validators_1 = require("./validators");
+Object.defineProperty(exports, "arrayValidator", { enumerable: true, get: function () { return validators_1.arrayValidator; } });
+Object.defineProperty(exports, "dateValidator", { enumerable: true, get: function () { return validators_1.dateValidator; } });
+Object.defineProperty(exports, "numberValidator", { enumerable: true, get: function () { return validators_1.numberValidator; } });
+Object.defineProperty(exports, "stringValidator", { enumerable: true, get: function () { return validators_1.stringValidator; } });

package/dist/proxy.d.ts

@@ -0,0 +1,2 @@
+export type ProxyChanged<T extends object> = (target: T, property: string, currentValue: unknown, oldValue: unknown) => void;
+export declare const ChangeProxy: <T extends object>(source: T, changed: ProxyChanged<T>) => T;

package/dist/proxy.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeProxy = void 0;
+const isProxiable = (value) => typeof value === 'object' &&
+    value !== null &&
+    !(value instanceof Date) &&
+    !(value instanceof Map) &&
+    !(value instanceof Set) &&
+    !(value instanceof WeakMap) &&
+    !(value instanceof WeakSet) &&
+    !(value instanceof RegExp) &&
+    !(value instanceof Error) &&
+    !(value instanceof Promise);
+const ChangeProxy = (source, changed) => {
+    const createProxy = (target, parentPath) => new Proxy(target, {
+        get(object, property, receiver) {
+            const value = Reflect.get(object, property, receiver);
+            if (isProxiable(value)) {
+                const pathSegment = Number.isInteger(Number(property)) ? '' : String(property);
+                const childPath = pathSegment ? (parentPath ? `${parentPath}.${pathSegment}` : pathSegment) : parentPath;
+                return createProxy(value, childPath);
+            }
+            return value;
+        },
+        set(object, property, incomingValue, receiver) {
+            const oldValue = Reflect.get(object, property, receiver);
+            if (oldValue !== incomingValue) {
+                Reflect.set(object, property, incomingValue, receiver);
+                const pathSegment = Number.isInteger(Number(property)) ? '' : String(property);
+                const fullPath = pathSegment ? (parentPath ? `${parentPath}.${pathSegment}` : pathSegment) : parentPath;
+                changed(data, fullPath, incomingValue, oldValue);
+            }
+            return true;
+        }
+    });
+    const data = createProxy(source, '');
+    return data;
+};
+exports.ChangeProxy = ChangeProxy;

package/dist/state.svelte.d.ts

@@ -0,0 +1,45 @@
+import { type Readable } from 'svelte/store';
+export type Validator = {
+    [S in string]: string | Validator;
+};
+type Action<P extends object> = (parameters?: P) => Promise<void> | void;
+export type Snapshot<T> = {
+    title: string;
+    data: T;
+};
+export type SnapshotFunction = (title: string, replace?: boolean) => void;
+export type EffectContext<T> = {
+    snapshot: SnapshotFunction;
+    target: T;
+    property: string;
+    currentValue: unknown;
+    oldValue: unknown;
+};
+type Actuators<T extends Record<string, unknown>, V extends Validator, P extends object> = {
+    validator?: (source: T) => V;
+    effect?: (context: EffectContext<T>) => void;
+    action?: Action<P>;
+    actionCompleted?: (error?: unknown) => void | Promise<void>;
+};
+type StateResult<T, V> = {
+    errors: Readable<V | undefined>;
+    hasErrors: Readable<boolean>;
+    isDirty: Readable<boolean>;
+    actionInProgress: Readable<boolean>;
+    actionError: Readable<Error | undefined>;
+    snapshots: Readable<Snapshot<T>[]>;
+};
+export type SvStateOptions = {
+    resetDirtyOnAction: boolean;
+    debounceValidation: number;
+    allowConcurrentActions: boolean;
+    persistActionError: boolean;
+};
+export declare function createSvState<T extends Record<string, unknown>, V extends Validator, P extends object>(init: T, actuators?: Actuators<T, V, P>, options?: Partial<SvStateOptions>): {
+    data: T;
+    execute: (parameters?: P) => Promise<void>;
+    state: StateResult<T, V>;
+    rollback: (steps?: number) => void;
+    reset: () => void;
+};
+export {};

package/dist/state.svelte.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSvState = createSvState;
+const store_1 = require("svelte/store");
+const proxy_1 = require("./proxy");
+const checkHasErrors = (validator) => Object.values(validator).some((item) => (typeof item === 'string' ? !!item : checkHasErrors(item)));
+const hasAnyErrors = ($errors) => !!$errors && checkHasErrors($errors);
+const deepClone = (object) => {
+    if (object === null || typeof object !== 'object')
+        return object;
+    if (object instanceof Date)
+        return new Date(object);
+    if (Array.isArray(object))
+        return object.map((item) => deepClone(item));
+    const cloned = {};
+    for (const key in object)
+        if (Object.prototype.hasOwnProperty.call(object, key))
+            cloned[key] = deepClone(object[key]);
+    return cloned;
+};
+const defaultOptions = {
+    resetDirtyOnAction: true,
+    debounceValidation: 0,
+    allowConcurrentActions: false,
+    persistActionError: false
+};
+function createSvState(init, actuators, options) {
+    const usedOptions = { ...defaultOptions, ...options };
+    const { validator, effect } = actuators ?? {};
+    const errors = (0, store_1.writable)();
+    const hasErrors = (0, store_1.derived)(errors, hasAnyErrors);
+    const isDirty = (0, store_1.writable)(false);
+    const actionInProgress = (0, store_1.writable)(false);
+    const actionError = (0, store_1.writable)();
+    const snapshots = (0, store_1.writable)([{ title: 'Initial', data: deepClone(init) }]);
+    const stateObject = $state(init);
+    const createSnapshot = (title, replace = true) => {
+        const currentSnapshots = (0, store_1.get)(snapshots);
+        const createdSnapshot = { title, data: deepClone(stateObject) };
+        const lastSnapshot = currentSnapshots.at(-1);
+        if (replace && lastSnapshot && lastSnapshot.title === title)
+            snapshots.set([...currentSnapshots.slice(0, -1), createdSnapshot]);
+        else
+            snapshots.set([...currentSnapshots, createdSnapshot]);
+    };
+    let validationScheduled = false;
+    let validationTimeout;
+    const scheduleValidation = () => {
+        if (!validator)
+            return;
+        if (usedOptions.debounceValidation > 0) {
+            clearTimeout(validationTimeout);
+            validationTimeout = setTimeout(() => {
+                errors.set(validator(data));
+            }, usedOptions.debounceValidation);
+        }
+        else {
+            if (validationScheduled)
+                return;
+            validationScheduled = true;
+            queueMicrotask(() => {
+                errors.set(validator(data));
+                validationScheduled = false;
+            });
+        }
+    };
+    const data = (0, proxy_1.ChangeProxy)(stateObject, (target, property, currentValue, oldValue) => {
+        if (!usedOptions.persistActionError)
+            actionError.set(undefined);
+        isDirty.set(true);
+        const effectResult = effect?.({ snapshot: createSnapshot, target, property, currentValue, oldValue });
+        if (effectResult instanceof Promise)
+            throw new Error('svstate: effect callback must be synchronous. Use action for async operations.');
+        scheduleValidation();
+    });
+    if (validator)
+        errors.set(validator(data));
+    const execute = async (parameters) => {
+        if (!usedOptions.allowConcurrentActions && (0, store_1.get)(actionInProgress))
+            return;
+        actionError.set(undefined);
+        actionInProgress.set(true);
+        try {
+            await actuators?.action?.(parameters);
+            if (usedOptions.resetDirtyOnAction)
+                isDirty.set(false);
+            snapshots.set([{ title: 'Initial', data: deepClone(stateObject) }]);
+            await actuators?.actionCompleted?.();
+        }
+        catch (caughtError) {
+            await actuators?.actionCompleted?.(caughtError);
+            actionError.set(caughtError instanceof Error ? caughtError : undefined);
+        }
+        finally {
+            actionInProgress.set(false);
+        }
+    };
+    const rollback = (steps = 1) => {
+        const currentSnapshots = (0, store_1.get)(snapshots);
+        if (currentSnapshots.length <= 1)
+            return;
+        const targetIndex = Math.max(0, currentSnapshots.length - 1 - steps);
+        const targetSnapshot = currentSnapshots[targetIndex];
+        if (!targetSnapshot)
+            return;
+        Object.assign(stateObject, deepClone(targetSnapshot.data));
+        snapshots.set(currentSnapshots.slice(0, targetIndex + 1));
+        if (validator)
+            errors.set(validator(data));
+    };
+    const reset = () => {
+        const currentSnapshots = (0, store_1.get)(snapshots);
+        const initialSnapshot = currentSnapshots[0];
+        if (!initialSnapshot)
+            return;
+        Object.assign(stateObject, deepClone(initialSnapshot.data));
+        snapshots.set([initialSnapshot]);
+        if (validator)
+            errors.set(validator(data));
+    };
+    const state = {
+        errors,
+        hasErrors,
+        isDirty,
+        actionInProgress,
+        actionError,
+        snapshots
+    };
+    return { data, execute, state, rollback, reset };
+}

package/dist/validators.d.ts

@@ -0,0 +1,60 @@
+type BaseOption = 'trim' | 'normalize';
+export declare function stringValidator(input: string, ...prepares: (BaseOption | 'upper')[]): StringValidatorBuilder;
+export declare function stringValidator(input: string, ...prepares: (BaseOption | 'lower')[]): StringValidatorBuilder;
+export declare function stringValidator(input: string, ...prepares: BaseOption[]): StringValidatorBuilder;
+type StringValidatorBuilder = {
+    required(): StringValidatorBuilder;
+    noSpace(): StringValidatorBuilder;
+    minLength(length: number): StringValidatorBuilder;
+    maxLength(length: number): StringValidatorBuilder;
+    uppercase(): StringValidatorBuilder;
+    lowercase(): StringValidatorBuilder;
+    startsWith(prefix: string | string[]): StringValidatorBuilder;
+    regexp(regexp: RegExp, message?: string): StringValidatorBuilder;
+    inArray(values: string[] | Record<string, unknown>): StringValidatorBuilder;
+    email(): StringValidatorBuilder;
+    website(prefix?: 'required' | 'forbidden' | 'optional'): StringValidatorBuilder;
+    endsWith(suffix: string | string[]): StringValidatorBuilder;
+    contains(substring: string): StringValidatorBuilder;
+    alphanumeric(): StringValidatorBuilder;
+    numeric(): StringValidatorBuilder;
+    getError(): string;
+};
+export declare function numberValidator(input: number): NumberValidatorBuilder;
+type NumberValidatorBuilder = {
+    required(): NumberValidatorBuilder;
+    min(n: number): NumberValidatorBuilder;
+    max(n: number): NumberValidatorBuilder;
+    between(min: number, max: number): NumberValidatorBuilder;
+    integer(): NumberValidatorBuilder;
+    positive(): NumberValidatorBuilder;
+    negative(): NumberValidatorBuilder;
+    nonNegative(): NumberValidatorBuilder;
+    multipleOf(n: number): NumberValidatorBuilder;
+    decimal(places: number): NumberValidatorBuilder;
+    percentage(): NumberValidatorBuilder;
+    getError(): string;
+};
+export declare function arrayValidator<T>(input: T[]): ArrayValidatorBuilder;
+type ArrayValidatorBuilder = {
+    required(): ArrayValidatorBuilder;
+    minLength(n: number): ArrayValidatorBuilder;
+    maxLength(n: number): ArrayValidatorBuilder;
+    unique(): ArrayValidatorBuilder;
+    getError(): string;
+};
+export declare function dateValidator(input: Date | string | number): DateValidatorBuilder;
+type DateValidatorBuilder = {
+    required(): DateValidatorBuilder;
+    before(target: Date | string | number): DateValidatorBuilder;
+    after(target: Date | string | number): DateValidatorBuilder;
+    between(start: Date | string | number, end: Date | string | number): DateValidatorBuilder;
+    past(): DateValidatorBuilder;
+    future(): DateValidatorBuilder;
+    weekday(): DateValidatorBuilder;
+    weekend(): DateValidatorBuilder;
+    minAge(years: number): DateValidatorBuilder;
+    maxAge(years: number): DateValidatorBuilder;
+    getError(): string;
+};
+export {};

package/dist/validators.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringValidator = stringValidator;
+exports.numberValidator = numberValidator;
+exports.arrayValidator = arrayValidator;
+exports.dateValidator = dateValidator;
+const prepareOps = {
+    trim: (s) => s.trim(),
+    normalize: (s) => s.replaceAll(/\s{2,}/g, ' '),
+    upper: (s) => s.toLocaleUpperCase(),
+    lower: (s) => s.toLocaleLowerCase()
+};
+function stringValidator(input, ...prepares) {
+    let error = '';
+    const setError = (message) => {
+        if (!error)
+            error = message;
+    };
+    const processedInput = prepares.reduce((s, op) => prepareOps[op](s), input);
+    const builder = {
+        required() {
+            if (!error && !processedInput)
+                setError('Required');
+            return builder;
+        },
+        noSpace() {
+            if (!error && processedInput.includes(' '))
+                setError('No space allowed');
+            return builder;
+        },
+        minLength(length) {
+            if (!error && processedInput.length < length)
+                setError(`Min length ${length}`);
+            return builder;
+        },
+        maxLength(length) {
+            if (!error && processedInput.length > length)
+                setError(`Max length ${length}`);
+            return builder;
+        },
+        uppercase() {
+            if (!error && processedInput !== processedInput.toLocaleUpperCase())
+                setError('Uppercase only');
+            return builder;
+        },
+        lowercase() {
+            if (!error && processedInput !== processedInput.toLocaleLowerCase())
+                setError('Lowercase only');
+            return builder;
+        },
+        startsWith(prefix) {
+            if (error)
+                return builder;
+            const prefixes = Array.isArray(prefix) ? prefix : [prefix];
+            if (processedInput && !prefixes.some((p) => processedInput.startsWith(p)))
+                setError(`Must start with ${prefixes.join(', ')}`);
+            return builder;
+        },
+        regexp(regexp, message) {
+            if (!error && processedInput && !regexp.test(processedInput))
+                setError(message ?? 'Not allowed chars');
+            return builder;
+        },
+        inArray(values) {
+            if (error)
+                return builder;
+            const allowed = Array.isArray(values) ? values : Object.keys(values);
+            if (processedInput && !allowed.includes(processedInput))
+                setError(`Must be one of: ${allowed.join(', ')}`);
+            return builder;
+        },
+        email() {
+            if (!error && processedInput && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(processedInput))
+                setError('Invalid email format');
+            return builder;
+        },
+        website(prefix = 'optional') {
+            if (error || !processedInput || prefix === 'optional')
+                return builder;
+            const hasPrefix = /^https?:\/\//.test(processedInput);
+            if (prefix === 'required' && !hasPrefix)
+                setError('Must start with http:// or https://');
+            else if (prefix === 'forbidden' && hasPrefix)
+                setError('Must not start with http:// or https://');
+            return builder;
+        },
+        endsWith(suffix) {
+            if (error || !processedInput)
+                return builder;
+            const suffixes = Array.isArray(suffix) ? suffix : [suffix];
+            if (!suffixes.some((s) => processedInput.endsWith(s)))
+                setError(`Must end with ${suffixes.join(', ')}`);
+            return builder;
+        },
+        contains(substring) {
+            if (!error && processedInput && !processedInput.includes(substring))
+                setError(`Must contain "${substring}"`);
+            return builder;
+        },
+        alphanumeric() {
+            if (!error && processedInput && !/^[\dA-Za-z]+$/.test(processedInput))
+                setError('Only letters and numbers allowed');
+            return builder;
+        },
+        numeric() {
+            if (!error && processedInput && !/^\d+$/.test(processedInput))
+                setError('Only numbers allowed');
+            return builder;
+        },
+        getError() {
+            return error;
+        }
+    };
+    return builder;
+}
+function numberValidator(input) {
+    let error = '';
+    const setError = (message) => {
+        if (!error)
+            error = message;
+    };
+    const builder = {
+        required() {
+            if (!error && Number.isNaN(input))
+                setError('Required');
+            return builder;
+        },
+        min(n) {
+            if (!error && input < n)
+                setError(`Minimum ${n}`);
+            return builder;
+        },
+        max(n) {
+            if (!error && input > n)
+                setError(`Maximum ${n}`);
+            return builder;
+        },
+        between(min, max) {
+            if (!error && (input < min || input > max))
+                setError(`Must be between ${min} and ${max}`);
+            return builder;
+        },
+        integer() {
+            if (!error && !Number.isInteger(input))
+                setError('Must be an integer');
+            return builder;
+        },
+        positive() {
+            if (!error && input <= 0)
+                setError('Must be positive');
+            return builder;
+        },
+        negative() {
+            if (!error && input >= 0)
+                setError('Must be negative');
+            return builder;
+        },
+        nonNegative() {
+            if (!error && input < 0)
+                setError('Must be non-negative');
+            return builder;
+        },
+        multipleOf(n) {
+            if (!error && input % n !== 0)
+                setError(`Must be a multiple of ${n}`);
+            return builder;
+        },
+        decimal(places) {
+            if (error || Number.isNaN(input))
+                return builder;
+            const parts = String(input).split('.');
+            const actualPlaces = parts[1]?.length ?? 0;
+            if (actualPlaces > places)
+                setError(`Maximum ${places} decimal places`);
+            return builder;
+        },
+        percentage() {
+            if (!error && (input < 0 || input > 100))
+                setError('Must be between 0 and 100');
+            return builder;
+        },
+        getError() {
+            return error;
+        }
+    };
+    return builder;
+}
+function arrayValidator(input) {
+    let error = '';
+    const setError = (message) => {
+        if (!error)
+            error = message;
+    };
+    const builder = {
+        required() {
+            if (!error && input.length === 0)
+                setError('Required');
+            return builder;
+        },
+        minLength(n) {
+            if (!error && input.length < n)
+                setError(`Minimum ${n} items`);
+            return builder;
+        },
+        maxLength(n) {
+            if (!error && input.length > n)
+                setError(`Maximum ${n} items`);
+            return builder;
+        },
+        unique() {
+            if (error)
+                return builder;
+            const seen = new Set();
+            for (const item of input) {
+                const key = typeof item === 'object' ? JSON.stringify(item) : String(item);
+                if (seen.has(key)) {
+                    setError('Items must be unique');
+                    break;
+                }
+                seen.add(key);
+            }
+            return builder;
+        },
+        getError() {
+            return error;
+        }
+    };
+    return builder;
+}
+function dateValidator(input) {
+    let error = '';
+    const setError = (message) => {
+        if (!error)
+            error = message;
+    };
+    const date = input instanceof Date ? input : new Date(input);
+    const isValid = !Number.isNaN(date.getTime());
+    const builder = {
+        required() {
+            if (!error && !isValid)
+                setError('Required');
+            return builder;
+        },
+        before(target) {
+            if (!error && isValid) {
+                const targetDate = target instanceof Date ? target : new Date(target);
+                if (date >= targetDate)
+                    setError(`Must be before ${targetDate.toISOString()}`);
+            }
+            return builder;
+        },
+        after(target) {
+            if (!error && isValid) {
+                const targetDate = target instanceof Date ? target : new Date(target);
+                if (date <= targetDate)
+                    setError(`Must be after ${targetDate.toISOString()}`);
+            }
+            return builder;
+        },
+        between(start, end) {
+            if (!error && isValid) {
+                const startDate = start instanceof Date ? start : new Date(start);
+                const endDate = end instanceof Date ? end : new Date(end);
+                if (date < startDate || date > endDate)
+                    setError(`Must be between ${startDate.toISOString()} and ${endDate.toISOString()}`);
+            }
+            return builder;
+        },
+        past() {
+            if (!error && isValid && date >= new Date())
+                setError('Must be in the past');
+            return builder;
+        },
+        future() {
+            if (!error && isValid && date <= new Date())
+                setError('Must be in the future');
+            return builder;
+        },
+        weekday() {
+            if (!error && isValid) {
+                const day = date.getDay();
+                if (day === 0 || day === 6)
+                    setError('Must be a weekday');
+            }
+            return builder;
+        },
+        weekend() {
+            if (!error && isValid) {
+                const day = date.getDay();
+                if (day !== 0 && day !== 6)
+                    setError('Must be a weekend');
+            }
+            return builder;
+        },
+        minAge(years) {
+            if (!error && isValid) {
+                const minDate = new Date();
+                minDate.setFullYear(minDate.getFullYear() - years);
+                if (date > minDate)
+                    setError(`Must be at least ${years} years ago`);
+            }
+            return builder;
+        },
+        maxAge(years) {
+            if (!error && isValid) {
+                const maxDate = new Date();
+                maxDate.setFullYear(maxDate.getFullYear() - years);
+                if (date < maxDate)
+                    setError(`Must be at most ${years} years ago`);
+            }
+            return builder;
+        },
+        getError() {
+            return error;
+        }
+    };
+    return builder;
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "svstate",
+  "version": "0.0.1",
+  "description": "Supercharged $state() for Svelte 5: deep reactive proxy with validation, cross-field rules, computed & side-effects",
+  "author": "BCsabaEngine",
+  "license": "ISC",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "engines": {
+    "node": ">=20",
+    "npm": ">=9"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BCsabaEngine/svstate.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BCsabaEngine/svstate/issues"
+  },
+  "homepage": "https://github.com/BCsabaEngine/svstate",
+  "scripts": {
+    "demo": "cd demo && ./node_modules/.bin/vite dev --host --open",
+    "demo:build": "cd demo && ./node_modules/.bin/vite build",
+    "test": "vitest run --pass-with-no-tests",
+    "test:coverage": "vitest run --coverage",
+    "clean": "tsc --build --clean",
+    "build": "tsc --build --clean && tsc --build --force",
+    "format:check": "prettier --check .",
+    "format:fix": "prettier --write . | grep -v 'unchanged' | sed G",
+    "lint:check": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "fix": "node --run format:fix && node --run lint:fix && node --run format:fix",
+    "all": "node --run fix && node --run build && node --run test && node --run demo:build",
+    "npm:reinstall": "rm -rf ./node_modules && rm -f ./package-lock.json && npm i && npm i"
+  },
+  "keywords": [
+    "svelte",
+    "svelte5",
+    "state",
+    "validation",
+    "runes",
+    "proxy"
+  ],
+  "devDependencies": {
+    "@sveltejs/vite-plugin-svelte": "^6.2.4",
+    "@types/node": "^25.0.9",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "@vitest/coverage-v8": "^4.0.17",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "nodemon": "^3.1.11",
+    "prettier": "^3.8.0",
+    "svelte": "^5.46.4",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  }
+}