@blueprint-ts/core 4.1.0-beta.6 → 5.0.0

package/dist/vue/forms/validation/rules/BaseRule.js

@@ -1,21 +1,8 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class BaseRule {
-    constructor() {
-        this.dependsOn = [];
-    }
+    dependsOn = [];
     // eslint-disable-next-line  @typescript-eslint/no-unused-vars
-    validateAsync(_value, _state, _context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return null;
-        });
+    async validateAsync(_value, _state, _context) {
+        return null;
     }
     // eslint-disable-next-line  @typescript-eslint/no-unused-vars
     getAsyncValidationPaths(field, _state) {

package/dist/vue/forms/validation/rules/ConfirmedRule.js

@@ -1,5 +1,7 @@
 import { BaseRule } from './BaseRule';
 export class ConfirmedRule extends BaseRule {
+    confirmationField;
+    message;
     constructor(confirmationField, message) {
         super();
         this.confirmationField = confirmationField;

package/dist/vue/forms/validation/rules/EmailRule.js

@@ -1,5 +1,6 @@
 import { BaseRule } from './BaseRule';
 export class EmailRule extends BaseRule {
+    message;
     constructor(message = 'Please enter a valid email address') {
         super();
         this.message = message;

package/dist/vue/forms/validation/rules/JsonRule.js

@@ -1,5 +1,6 @@
 import { BaseRule } from './BaseRule';
 export class JsonRule extends BaseRule {
+    message;
     constructor(message = 'Please enter valid JSON') {
         super();
         this.message = message;
@@ -15,7 +16,7 @@ export class JsonRule extends BaseRule {
             JSON.parse(value);
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
     }

package/dist/vue/forms/validation/rules/MinRule.js

@@ -1,5 +1,7 @@
 import { BaseRule } from './BaseRule';
 export class MinRule extends BaseRule {
+    min;
+    message;
     /**
      * Creates a new MinRule
      * @param min The minimum value (length for strings, value for numbers, length for arrays)

package/dist/vue/forms/validation/rules/PrecognitiveRule.js

@@ -1,15 +1,8 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { ValidationException } from '../../../../requests/exceptions/ValidationException';
 import { BaseRule } from './BaseRule';
 export class PrecognitiveRule extends BaseRule {
+    requestFactory;
+    options;
     constructor(requestFactory, options = {}) {
         super();
         this.requestFactory = requestFactory;
@@ -31,28 +24,25 @@ export class PrecognitiveRule extends BaseRule {
         }
         return [String(field)];
     }
-    validateAsync(_value, state, context) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            const request = this.requestFactory();
-            const validateOnly = this.getAsyncValidationPaths(context.field, state);
-            request.setBody(context.payload);
-            request.setHeaders({
-                Accept: (_a = this.options.acceptHeader) !== null && _a !== void 0 ? _a : 'application/json',
-                Precognition: 'true',
-                'Precognition-Validate-Only': validateOnly.join(',')
-            });
-            try {
-                yield request.send({ resolveBody: false });
-                return {};
-            }
-            catch (error) {
-                if (error instanceof ValidationException) {
-                    const body = error.getBody();
-                    return (_e = (_d = (_c = (_b = this.options).resolveErrors) === null || _c === void 0 ? void 0 : _c.call(_b, body)) !== null && _d !== void 0 ? _d : body.errors) !== null && _e !== void 0 ? _e : {};
-                }
-                throw error;
-            }
+    async validateAsync(_value, state, context) {
+        const request = this.requestFactory();
+        const validateOnly = this.getAsyncValidationPaths(context.field, state);
+        request.setBody(context.payload);
+        request.setHeaders({
+            Accept: this.options.acceptHeader ?? 'application/json',
+            Precognition: 'true',
+            'Precognition-Validate-Only': validateOnly.join(',')
         });
+        try {
+            await request.send({ resolveBody: false });
+            return {};
+        }
+        catch (error) {
+            if (error instanceof ValidationException) {
+                const body = error.getBody();
+                return this.options.resolveErrors?.(body) ?? body.errors ?? {};
+            }
+            throw error;
+        }
     }
 }

package/dist/vue/forms/validation/rules/RequiredRule.js

@@ -1,5 +1,6 @@
 import { BaseRule } from './BaseRule';
 export class RequiredRule extends BaseRule {
+    message;
     constructor(message = 'This field is required') {
         super();
         this.message = message;

package/dist/vue/forms/validation/rules/UrlRule.js

@@ -1,5 +1,6 @@
 import { BaseRule } from './BaseRule';
 export class UrlRule extends BaseRule {
+    message;
     constructor(message = 'Please enter a valid URL') {
         super();
         this.message = message;
@@ -12,7 +13,7 @@ export class UrlRule extends BaseRule {
             new URL(value);
             return true;
         }
-        catch (_a) {
+        catch {
             return false;
         }
     }

package/dist/vue/requests/loaders/VueRequestBatchLoader.js

@@ -1,9 +1,9 @@
 import { ref, computed } from 'vue';
 export class VueRequestBatchLoader {
+    inFlight = ref(0);
+    completed = ref(0);
+    expected = 0;
     constructor(expectedRequests = 0) {
-        this.inFlight = ref(0);
-        this.completed = ref(0);
-        this.expected = 0;
         this.expected = expectedRequests;
     }
     startBatch(count) {

package/dist/vue/requests/loaders/VueRequestLoader.js

@@ -1,5 +1,6 @@
 import { ref } from 'vue';
 export class VueRequestLoader {
+    loading;
     constructor(initialLoading = false) {
         this.loading = ref(initialLoading);
     }

package/dist/vue/router/routeResourceBinding/RouteResourceBoundView.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { computed, defineComponent, h } from 'vue';
 import { RouterView, useRoute } from 'vue-router';
 /**
@@ -75,7 +66,7 @@ export const RouteResourceBoundView = defineComponent({
                 return null;
             for (const key of Object.keys(state)) {
                 const entry = state[key];
-                if (entry === null || entry === void 0 ? void 0 : entry.error)
+                if (entry?.error)
                     return entry.error;
             }
             return null;
@@ -84,21 +75,20 @@ export const RouteResourceBoundView = defineComponent({
             const state = injectionState.value;
             if (!state)
                 return false;
-            return Object.keys(state).some((key) => { var _a; return (_a = state[key]) === null || _a === void 0 ? void 0 : _a.loading; });
+            return Object.keys(state).some((key) => state[key]?.loading);
         });
-        const refresh = () => __awaiter(this, void 0, void 0, function* () {
+        const refresh = async () => {
             const state = injectionState.value;
             if (!state)
                 return;
-            const erroredProps = Object.keys(state).filter((key) => { var _a; return (_a = state[key]) === null || _a === void 0 ? void 0 : _a.error; });
-            yield Promise.all(erroredProps.map((propName) => { var _a, _b; return (_b = (_a = route.meta).refresh) === null || _b === void 0 ? void 0 : _b.call(_a, propName); }));
-        });
+            const erroredProps = Object.keys(state).filter((key) => state[key]?.error);
+            await Promise.all(erroredProps.map((propName) => route.meta.refresh?.(propName)));
+        };
         /**
          * Core render logic that decides which slot/component to show
          * given the resolved Component and route from RouterView.
          */
         function renderContent(Component, resolvedRoute) {
-            var _a, _b;
             const isLazy = resolvedRoute.meta._lazy !== false;
             if (isLazy) {
                 if (firstError.value) {
@@ -106,14 +96,14 @@ export const RouteResourceBoundView = defineComponent({
                     if (errorComponent) {
                         return h(errorComponent, { error: firstError.value, refresh });
                     }
-                    return (_a = slots['error']) === null || _a === void 0 ? void 0 : _a.call(slots, { error: firstError.value, refresh });
+                    return slots['error']?.({ error: firstError.value, refresh });
                 }
                 if (anyLoading.value) {
                     const loadingComponent = resolvedRoute.meta._loadingComponent;
                     if (loadingComponent) {
                         return h(loadingComponent);
                     }
-                    return (_b = slots['loading']) === null || _b === void 0 ? void 0 : _b.call(slots);
+                    return slots['loading']?.();
                 }
             }
             if (slots['default']) {

package/dist/vue/router/routeResourceBinding/RouteResourceRequestResolver.js

@@ -1,20 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 export class RouteResourceRequestResolver {
+    request;
     constructor(request) {
         this.request = request;
     }
-    resolve() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.request.send();
-            return response.getData();
-        });
+    async resolve() {
+        const response = await this.request.send();
+        return response.getData();
     }
 }

package/dist/vue/router/routeResourceBinding/defineRoute.js

@@ -15,27 +15,28 @@ import { markRaw } from 'vue';
  */
 export function defineRoute() {
     return function (route) {
-        var _a, _b, _c;
         const originalProps = route.props;
         if (route.errorComponent) {
-            route.meta = (_a = route.meta) !== null && _a !== void 0 ? _a : {};
+            route.meta = route.meta ?? {};
             route.meta._errorComponent = markRaw(route.errorComponent);
             delete route.errorComponent;
         }
         if (route.loadingComponent) {
-            route.meta = (_b = route.meta) !== null && _b !== void 0 ? _b : {};
+            route.meta = route.meta ?? {};
             route.meta._loadingComponent = markRaw(route.loadingComponent);
             delete route.loadingComponent;
         }
         if (route.lazy !== undefined) {
-            route.meta = (_c = route.meta) !== null && _c !== void 0 ? _c : {};
+            route.meta = route.meta ?? {};
             route.meta._lazy = route.lazy;
             delete route.lazy;
         }
         route.props = (to) => {
-            var _a;
-            const baseProps = typeof originalProps === 'function' ? originalProps(to) : originalProps === true ? to.params : (originalProps !== null && originalProps !== void 0 ? originalProps : {});
-            return Object.assign(Object.assign({}, baseProps), ((_a = to.meta._injectedProps) !== null && _a !== void 0 ? _a : {}));
+            const baseProps = typeof originalProps === 'function' ? originalProps(to) : originalProps === true ? to.params : (originalProps ?? {});
+            return {
+                ...baseProps,
+                ...(to.meta._injectedProps ?? {})
+            };
         };
         return route;
     };

package/dist/vue/router/routeResourceBinding/installRouteInjection.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { reactive } from 'vue';
 /**
  * Installs the runtime part:
@@ -22,7 +13,7 @@ import { reactive } from 'vue';
  */
 export function installRouteInjection(router) {
     const cache = {};
-    router.beforeResolve((to) => __awaiter(this, void 0, void 0, function* () {
+    router.beforeResolve(async (to) => {
         console.log('[Route Injection] Resolving route injections...');
         if (!to.meta._injectedProps) {
             to.meta._injectedProps = reactive({});
@@ -60,15 +51,15 @@ export function installRouteInjection(router) {
                     state[propName] = reactive({ loading: false, error: null });
                 }
                 // Define the refresh logic for this specific prop (always fetches fresh data)
-                const resolveProp = (options) => __awaiter(this, void 0, void 0, function* () {
+                const resolveProp = async (options) => {
                     const propState = to.meta._injectionState[propName];
-                    if (!(options === null || options === void 0 ? void 0 : options.silent)) {
+                    if (!options?.silent) {
                         propState.loading = true;
                     }
                     propState.error = null;
                     try {
                         const resolver = cfg.resolve(paramValue);
-                        let payload = yield resolver.resolve();
+                        let payload = await resolver.resolve();
                         if (typeof cfg.getter === 'function') {
                             payload = cfg.getter(payload);
                         }
@@ -86,7 +77,7 @@ export function installRouteInjection(router) {
                     finally {
                         propState.loading = false;
                     }
-                });
+                };
                 resolvers[propName] = resolveProp;
                 // Reuse cached value if the param hasn't changed (e.g. navigating between child routes)
                 const cached = cache[propName];
@@ -99,14 +90,14 @@ export function installRouteInjection(router) {
                 // Set loading immediately and queue resolver (non-blocking)
                 const injectionState = to.meta._injectionState;
                 injectionState[propName].loading = true;
-                pendingResolvers.push(() => __awaiter(this, void 0, void 0, function* () {
+                pendingResolvers.push(async () => {
                     try {
-                        yield resolveProp();
+                        await resolveProp();
                     }
                     catch (e) {
                         console.error(`[Route Injection] Failed to resolve prop "${propName}"`, e);
                     }
-                }));
+                });
                 console.debug(`[Route Injection] Queued resolution for prop "${propName}" for route "${record.path}"`);
             }
         }
@@ -118,16 +109,16 @@ export function installRouteInjection(router) {
         }
         // Attach the resolvers and a global refresh helper to the route meta
         to.meta['_injectedResolvers'] = resolvers;
-        to.meta['refresh'] = (propName, options) => __awaiter(this, void 0, void 0, function* () {
+        to.meta['refresh'] = async (propName, options) => {
             if (resolvers[propName]) {
-                return yield resolvers[propName](options);
+                return await resolvers[propName](options);
             }
             console.warn(`[Route Injection] No resolver found for "${propName}"`);
             return undefined;
-        });
+        };
         // Fire pending resolvers without blocking navigation
         if (pendingResolvers.length > 0) {
             Promise.all(pendingResolvers.map((fn) => fn()));
         }
-    }));
+    });
 }

package/dist/vue/router/routeResourceBinding/useRouteResource.js

@@ -1,29 +1,17 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { computed } from 'vue';
 import { useRoute } from 'vue-router';
 export function useRouteResource(propName) {
     const route = useRoute();
-    const refresh = (options) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        return yield ((_b = (_a = route.meta).refresh) === null || _b === void 0 ? void 0 : _b.call(_a, propName, options));
-    });
+    const refresh = async (options) => {
+        return await route.meta.refresh?.(propName, options);
+    };
     const isLoading = computed(() => {
-        var _a, _b;
         const state = route.meta._injectionState;
-        return (_b = (_a = state === null || state === void 0 ? void 0 : state[propName]) === null || _a === void 0 ? void 0 : _a.loading) !== null && _b !== void 0 ? _b : false;
+        return state?.[propName]?.loading ?? false;
     });
     const error = computed(() => {
-        var _a, _b;
         const state = route.meta._injectionState;
-        return (_b = (_a = state === null || state === void 0 ? void 0 : state[propName]) === null || _a === void 0 ? void 0 : _a.error) !== null && _b !== void 0 ? _b : null;
+        return state?.[propName]?.error ?? null;
     });
     return { refresh, isLoading, error };
 }

package/dist/vue/state/State.d.ts

@@ -1,6 +1,7 @@
 import { type PersistenceDriver } from '../../persistenceDrivers';
 export interface StateOptions {
     persist?: boolean;
+    persistKey?: string;
     persistSuffix?: string;
 }
 /** Generic type for change handlers. */
@@ -24,6 +25,7 @@ export declare abstract class State<T extends object> {
     private _resetHandlers;
     private _watchIdCounter;
     protected constructor(initial: T, options?: StateOptions);
+    private resolvePersistKey;
     /**
      * Safe deep clone that preserves types
      */

package/dist/vue/state/State.js

@@ -15,15 +15,19 @@ function getNestedValue(root, pathParts) {
     return current;
 }
 export class State {
+    properties;
+    _initial;
+    _persist;
+    _persistKey;
+    _driver;
+    _stateProxy = null;
+    _watchStopFunctions = new Map();
+    _resetHandlers = new Map();
+    _watchIdCounter = 0;
     constructor(initial, options) {
-        this._stateProxy = null;
-        this._watchStopFunctions = new Map();
-        this._resetHandlers = new Map();
-        this._watchIdCounter = 0;
         this._initial = initial;
-        this._persist = !!(options === null || options === void 0 ? void 0 : options.persist);
-        const className = this.constructor.name;
-        this._persistKey = className + ((options === null || options === void 0 ? void 0 : options.persistSuffix) ? `_${options.persistSuffix}` : '');
+        this._persist = !!options?.persist;
+        this._persistKey = this.resolvePersistKey(options);
         this._driver = this.getPersistenceDriver();
         let loaded = null;
         if (this._persist) {
@@ -38,7 +42,7 @@ export class State {
                 }
             }
         }
-        const base = loaded !== null && loaded !== void 0 ? loaded : initial;
+        const base = loaded ?? initial;
         this.properties = {};
         const keys = Object.keys(base);
         for (const k of keys) {
@@ -56,6 +60,15 @@ export class State {
             });
         }
     }
+    resolvePersistKey(options) {
+        if (this._persist && !options?.persistKey) {
+            throw new Error('State persistence requires a stable persistKey option.');
+        }
+        if (!options?.persistKey) {
+            return '';
+        }
+        return options.persistSuffix ? `${options.persistKey}_${options.persistSuffix}` : options.persistKey;
+    }
     /**
      * Safe deep clone that preserves types
      */
@@ -115,7 +128,7 @@ export class State {
                     ;
                     handler(path, this.export());
                 };
-                if (options === null || options === void 0 ? void 0 : options.executeOnReset) {
+                if (options?.executeOnReset) {
                     resetHandlers.push(pathHandler);
                 }
                 const stop = this.setupWatcher(path, pathHandler, options);
@@ -124,7 +137,7 @@ export class State {
         }
         else {
             const pathHandler = handler;
-            if (options === null || options === void 0 ? void 0 : options.executeOnReset) {
+            if (options?.executeOnReset) {
                 resetHandlers.push(() => pathHandler(undefined, undefined));
             }
             const stop = this.setupWatcher(paths, pathHandler, options);
@@ -144,7 +157,7 @@ export class State {
      */
     setupWatcher(path, handler, options) {
         const pathParts = path.split('.');
-        const debouncedHandler = (options === null || options === void 0 ? void 0 : options.debounce) && options.debounce > 0 ? debounce(handler, options.debounce) : undefined;
+        const debouncedHandler = options?.debounce && options.debounce > 0 ? debounce(handler, options.debounce) : undefined;
         const effectiveHandler = debouncedHandler || handler;
         if (pathParts.length === 1 && path in this.properties) {
             const key = path;

package/dist/vue/state/index.d.ts

@@ -1,2 +1,3 @@
-import { State } from './State';
+import { State, type StateOptions } from './State';
 export { State };
+export type { StateOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueprint-ts/core",
-  "version": "4.1.0-beta.6",
+  "version": "5.0.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -85,7 +85,7 @@
   },
   "scripts": {
     "dev": "vite",
-    "build": "run-p type-check build:package \"build-only {@}\" --",
+    "build": "run-p type-check build:package",
     "build:package": "tsc -p tsconfig.build.json",
     "preview": "vite preview",
     "test": "vitest",
@@ -103,37 +103,37 @@
     "prepare": "npm run build:package"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@rushstack/eslint-patch": "^1.3.3",
     "@tsconfig/node20": "^20.1.2",
-    "@types/jsdom": "^21.1.6",
+    "@types/jsdom": "^28.0.3",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^20.11.28",
-    "@types/qs": "^6.9.18",
-    "@typescript-eslint/eslint-plugin": "^8.21.0",
-    "@typescript-eslint/parser": "^8.21.0",
-    "@typescript-eslint/typescript-estree": "^8.21.0",
-    "@vitejs/plugin-vue": "^5.0.4",
-    "@vitejs/plugin-vue-jsx": "^3.1.0",
-    "@vitest/coverage-v8": "^3.0.4",
-    "@vue/eslint-config-typescript": "^14.0.0",
-    "autoprefixer": "^10.4.19",
-    "eslint": "^9.0.0",
+    "@types/node": "^26.0.0",
+    "@types/qs": "^6.15.1",
+    "@typescript-eslint/eslint-plugin": "^8.62.0",
+    "@typescript-eslint/parser": "^8.62.0",
+    "@typescript-eslint/typescript-estree": "^8.62.0",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "@vitest/coverage-v8": "^4.1.9",
+    "@vue/eslint-config-typescript": "^14.9.0",
+    "autoprefixer": "^10.5.0",
+    "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.0.1",
-    "eslint-plugin-vue": "^9.31.0",
-    "jsdom": "^24.0.0",
-    "npm-run-all2": "^6.1.2",
-    "prettier": "^3.0.3",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.21.0",
-    "vite": "^5.1.6",
+    "eslint-plugin-vue": "^10.9.2",
+    "jsdom": "^29.1.1",
+    "npm-run-all2": "^9.0.2",
+    "prettier": "^3.8.4",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.62.0",
+    "vite": "^8.0.16",
     "vitepress": "^1.6.3",
-    "vitest": "^3.0.4",
-    "vue": "^3.4.25",
-    "vue-router": "^4.3.2"
+    "vitest": "^4.1.9",
+    "vue": "^3.5.38",
+    "vue-router": "^5.1.0"
   },
   "dependencies": {
-    "lodash-es": "^4.17.23",
-    "qs": "^6.15.0",
-    "uuid": "^13.0.0"
+    "lodash-es": "^4.18.1",
+    "qs": "^6.15.2",
+    "uuid": "^14.0.1"
   }
 }