@quvel-kit/core 1.1.0

package/dist/services/I18nService.js

@@ -0,0 +1,92 @@
+/**
+ * I18n Service
+ *
+ * Service for managing internationalization with vue-i18n
+ */
+import { Service } from './Service.js';
+import { isValidLocale, storeLocale, createI18n } from '../utils/i18n.js';
+import { getAcceptLanguageHeader } from '../utils/headers.js';
+/**
+ * I18n Service for managing localization
+ *
+ * IMPORTANT: You must call I18nService.setTranslations() before booting the container
+ */
+export class I18nService extends Service {
+    static translations = null;
+    i18n;
+    api;
+    config;
+    /**
+     * Set translations for all supported locales
+     * Must be called before booting the service
+     *
+     * @param messages - Translation messages keyed by locale (e.g., { 'en-US': {...}, 'es-MX': {...} })
+     */
+    static setTranslations(messages) {
+        I18nService.translations = messages;
+    }
+    constructor(config, ssrContext) {
+        super(config, ssrContext);
+        this.config = config;
+        this.i18n = createI18n(I18nService.translations, ssrContext, this.config);
+    }
+    /**
+     * Register with container (called first)
+     */
+    register({ api }) {
+        this.api = api;
+    }
+    /**
+     * Boot method to set up the API locale header after all services are ready
+     */
+    boot() {
+        this.setApiLocaleHeader();
+    }
+    /**
+     * Get the i18n instance
+     */
+    get instance() {
+        return this.i18n;
+    }
+    /**
+     * Get current locale
+     */
+    get locale() {
+        return this.i18n.global.locale.value;
+    }
+    /**
+     * Set current locale
+     */
+    set locale(value) {
+        this.changeLocale(value);
+    }
+    /**
+     * Sets the locale header for API requests
+     */
+    setApiLocaleHeader() {
+        const headerName = getAcceptLanguageHeader(this.config);
+        this.api.instance.defaults.headers.common[headerName] = this.i18n.global.locale.value;
+    }
+    /**
+     * Changes the locale and stores it persistently
+     */
+    changeLocale(locale) {
+        if (isValidLocale(locale, this.config)) {
+            this.i18n.global.locale.value = locale;
+            storeLocale(locale, this.config);
+            this.setApiLocaleHeader();
+        }
+    }
+    /**
+     * Translates a message using the current locale
+     */
+    t(key, params = {}) {
+        return this.i18n.global.t(key, params);
+    }
+    /**
+     * Checks if a translation exists
+     */
+    te(key) {
+        return this.i18n.global.te(key);
+    }
+}

package/dist/services/LogService.d.ts

@@ -0,0 +1,31 @@
+import type { QSsrContext } from '@quasar/app-vite';
+import type { LoggerInterface } from '../types/logging.types.js';
+import type { AppConfig } from '../types/app.types.js';
+import { Service } from './Service.js';
+/**
+ * Log Service
+ *
+ * Provides application logging and tracing capabilities
+ * - SSR: Uses trace context from AppConfig
+ * - Client: Uses trace context from AppConfig or creates default
+ */
+export declare class LogService extends Service {
+    private readonly logger;
+    constructor(config: AppConfig, ssrContext?: QSsrContext | null);
+    /**
+     * Get the current logger instance
+     */
+    getLogger(): LoggerInterface;
+    /**
+     * Proxy logger methods for convenience
+     */
+    emergency(message: string, context?: Record<string, unknown>): void;
+    alert(message: string, context?: Record<string, unknown>): void;
+    critical(message: string, context?: Record<string, unknown>): void;
+    error(message: string, context?: Record<string, unknown>): void;
+    warning(message: string, context?: Record<string, unknown>): void;
+    notice(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+}
+//# sourceMappingURL=LogService.d.ts.map

package/dist/services/LogService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogService.d.ts","sourceRoot":"","sources":["../../src/services/LogService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,OAAO;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;gBAE7B,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI;IAM9D;;OAEG;IACH,SAAS,IAAI,eAAe;IAI5B;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAInE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI/D,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIlE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI/D,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIjE,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIhE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;CAGhE"}

package/dist/services/LogService.js

@@ -0,0 +1,49 @@
+import { createLogger } from '../utils/logging.js';
+import { Service } from './Service.js';
+/**
+ * Log Service
+ *
+ * Provides application logging and tracing capabilities
+ * - SSR: Uses trace context from AppConfig
+ * - Client: Uses trace context from AppConfig or creates default
+ */
+export class LogService extends Service {
+    logger;
+    constructor(config, ssrContext) {
+        super(config, ssrContext);
+        this.logger = createLogger(config ?? undefined);
+    }
+    /**
+     * Get the current logger instance
+     */
+    getLogger() {
+        return this.logger;
+    }
+    /**
+     * Proxy logger methods for convenience
+     */
+    emergency(message, context) {
+        this.logger.emergency(message, context);
+    }
+    alert(message, context) {
+        this.logger.alert(message, context);
+    }
+    critical(message, context) {
+        this.logger.critical(message, context);
+    }
+    error(message, context) {
+        this.logger.error(message, context);
+    }
+    warning(message, context) {
+        this.logger.warning(message, context);
+    }
+    notice(message, context) {
+        this.logger.notice(message, context);
+    }
+    info(message, context) {
+        this.logger.info(message, context);
+    }
+    debug(message, context) {
+        this.logger.debug(message, context);
+    }
+}

package/dist/services/Service.d.ts

@@ -0,0 +1,10 @@
+import type { QSsrContext } from '@quasar/app-vite';
+import type { Service as IService } from '../container/types.js';
+import type { AppConfig } from '../types/app.types.js';
+/**
+ * Base class for all services
+ */
+export declare class Service implements IService {
+    constructor(_config: AppConfig, _ssrContext?: QSsrContext | null);
+}
+//# sourceMappingURL=Service.d.ts.map

package/dist/services/Service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Service.d.ts","sourceRoot":"","sources":["../../src/services/Service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;GAEG;AACH,qBAAa,OAAQ,YAAW,QAAQ;gBAEpC,OAAO,EAAE,SAAS,EAClB,WAAW,CAAC,EAAE,WAAW,GAAG,IAAI;CAInC"}

package/dist/services/Service.js

@@ -0,0 +1,8 @@
+/**
+ * Base class for all services
+ */
+export class Service {
+    constructor(_config, _ssrContext) {
+        // Base class accepts config and ssrContext for subclass compatibility
+    }
+}

package/dist/services/TaskService.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Task Service
+ *
+ * Manages async operations with built-in error handling, notifications, and loading indicators.
+ */
+import { type Ref, type ComputedRef } from 'vue';
+import type { TaskOptions, TaskState, ErrorBag } from '../types/task.types.js';
+import type { RegisterService } from '../container/types.js';
+import type { ServiceContainer } from '../container/ServiceContainer.js';
+import { Service } from './Service.js';
+import { LaravelErrorHandler } from '../utils/error.js';
+/**
+ * Task Service - Manages async operations with built-in error handling, notifications, and loading
+ */
+export declare class TaskService extends Service implements RegisterService {
+    private i18n;
+    /**
+     * Common error handlers
+     */
+    readonly errorHandlers: Readonly<{
+        Laravel: typeof LaravelErrorHandler;
+    }>;
+    /**
+     * Injects the service container dependencies
+     */
+    register({ i18n }: ServiceContainer): void;
+    /**
+     * Creates a new managed task
+     */
+    task<Result = unknown, Payload = unknown>(options: TaskOptions<Result, Payload>, mutableProps?: (keyof TaskOptions<Result, Payload>)[]): {
+        isActive: ComputedRef<boolean>;
+        run: (customOptions?: Partial<TaskOptions<Result, Payload>>) => Promise<Result | false>;
+        reset: () => void;
+        state: Ref<TaskState>;
+        error: Ref<unknown>;
+        errors: Ref<ErrorBag>;
+        result: Ref<Result | undefined>;
+    };
+    /**
+     * Resets the task state
+     */
+    private resetTask;
+    /**
+     * Runs the task
+     */
+    private runTask;
+    /**
+     * Merges task options with custom options based on mutable properties
+     */
+    private mergeTaskOptions;
+    /**
+     * Prepares error handlers, prepending Laravel handler if enabled
+     */
+    private prepareErrorHandlers;
+    /**
+     * Handles the completion of the task
+     */
+    private handleTaskCompletion;
+    /**
+     * Shows a notification based on the resolved notification value
+     */
+    private showResolvedNotification;
+}
+//# sourceMappingURL=TaskService.d.ts.map

package/dist/services/TaskService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskService.d.ts","sourceRoot":"","sources":["../../src/services/TaskService.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAiB,KAAK,GAAG,EAAE,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAChE,OAAO,KAAK,EAQV,WAAW,EACX,SAAS,EACT,QAAQ,EACT,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD;;GAEG;AACH,qBAAa,WAAY,SAAQ,OAAQ,YAAW,eAAe;IACjE,OAAO,CAAC,IAAI,CAAe;IAE3B;;OAEG;IACH,QAAQ,CAAC,aAAa;;OAEnB;IAEH;;OAEG;IACI,QAAQ,CAAC,EAAE,IAAI,EAAE,EAAE,gBAAgB,GAAG,IAAI;IAIjD;;OAEG;IACI,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO,EAC7C,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,YAAY,GAAE,CAAC,MAAM,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAO,GACxD;QACD,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,CAAC;QAC/B,GAAG,EAAE,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;QACxF,KAAK,EAAE,MAAM,IAAI,CAAC;QAClB,KAAK,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;QACtB,KAAK,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;QACpB,MAAM,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;QACtB,MAAM,EAAE,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;KACjC;IAsCD;;OAEG;IACH,OAAO,CAAC,SAAS;IAYjB;;OAEG;YACW,OAAO;IAgErB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAoBxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAgC5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA2C5B;;OAEG;YACW,wBAAwB;CAqBvC"}

package/dist/services/TaskService.js

@@ -0,0 +1,188 @@
+/**
+ * Task Service
+ *
+ * Manages async operations with built-in error handling, notifications, and loading indicators.
+ */
+import { computed, ref } from 'vue';
+import { Service } from './Service.js';
+import { showNotification } from '../utils/notify.js';
+import { getSafe, resolveValue } from '../utils/object.js';
+import { hideLoading, showLoading } from '../utils/loading.js';
+import { LaravelErrorHandler } from '../utils/error.js';
+/**
+ * Task Service - Manages async operations with built-in error handling, notifications, and loading
+ */
+export class TaskService extends Service {
+    i18n;
+    /**
+     * Common error handlers
+     */
+    errorHandlers = Object.freeze({
+        Laravel: LaravelErrorHandler,
+    });
+    /**
+     * Injects the service container dependencies
+     */
+    register({ i18n }) {
+        this.i18n = i18n;
+    }
+    /**
+     * Creates a new managed task
+     */
+    task(options, mutableProps = []) {
+        const currentError = ref();
+        const currentErrors = ref(new Map());
+        const currentResult = ref();
+        const currentState = ref('fresh');
+        const isActive = computed(() => currentState.value === 'active');
+        // Create bound methods with proper type preservation
+        const run = async (customOptions) => {
+            return this.runTask(options, mutableProps, currentError, currentErrors, currentResult, currentState, customOptions);
+        };
+        const reset = () => {
+            this.resetTask(currentError, currentErrors, currentResult, currentState);
+        };
+        return {
+            isActive,
+            run,
+            reset,
+            state: currentState,
+            error: currentError,
+            errors: currentErrors,
+            result: currentResult,
+        };
+    }
+    /**
+     * Resets the task state
+     */
+    resetTask(currentError, currentErrors, currentResult, currentState) {
+        currentError.value = undefined;
+        currentErrors.value = new Map();
+        currentResult.value = undefined;
+        currentState.value = 'fresh';
+    }
+    /**
+     * Runs the task
+     */
+    async runTask(options, mutableProps, currentError, currentErrors, currentResult, currentState, customOptions) {
+        this.resetTask(currentError, currentErrors, currentResult, currentState);
+        currentState.value = 'active';
+        // Merge options
+        const taskOptions = this.mergeTaskOptions(options, mutableProps, customOptions);
+        // Check if a task should run
+        if ((await resolveValue(taskOptions.shouldRun)) === false) {
+            return false;
+        }
+        // Handle loading indicator
+        const shouldShowLoading = await resolveValue(taskOptions.showLoading);
+        if (shouldShowLoading === true) {
+            showLoading(0, taskOptions.loadingOptions);
+        }
+        try {
+            const result = await taskOptions.task(await resolveValue(taskOptions.taskPayload));
+            currentResult.value = result;
+            currentState.value = 'success';
+            this.handleTaskCompletion(result, currentErrors, taskOptions.successHandlers, taskOptions.showNotification?.success, false);
+            return currentResult.value;
+        }
+        catch (error) {
+            currentError.value = error;
+            currentState.value = 'error';
+            const errorHandlers = this.prepareErrorHandlers(taskOptions);
+            this.handleTaskCompletion(error, currentErrors, errorHandlers, taskOptions.showNotification?.error, true);
+            return false;
+        }
+        finally {
+            await taskOptions.always?.();
+            if (shouldShowLoading === true)
+                hideLoading();
+        }
+    }
+    /**
+     * Merges task options with custom options based on mutable properties
+     */
+    mergeTaskOptions(options, mutableProps, customOptions) {
+        if (mutableProps.length > 0 && customOptions) {
+            const filteredOptions = {};
+            for (const key of Object.keys(customOptions)) {
+                if (mutableProps.includes(key)) {
+                    filteredOptions[key] = customOptions[key];
+                }
+            }
+            return { ...options, ...filteredOptions };
+        }
+        return customOptions ? { ...options, ...customOptions } : options;
+    }
+    /**
+     * Prepares error handlers, prepending Laravel handler if enabled
+     */
+    prepareErrorHandlers(taskOptions) {
+        if (taskOptions.handleLaravelError === false) {
+            return taskOptions.errorHandlers;
+        }
+        const laravelOptions = typeof taskOptions.handleLaravelError === 'object' ? taskOptions.handleLaravelError : {};
+        const { userCallBack, translate } = laravelOptions;
+        const laravelHandler = this.errorHandlers.Laravel(userCallBack, translate);
+        if (!taskOptions.errorHandlers) {
+            return [laravelHandler];
+        }
+        if (Array.isArray(taskOptions.errorHandlers)) {
+            return [laravelHandler, ...taskOptions.errorHandlers];
+        }
+        const errorHandler = {
+            callback: (payload, context) => {
+                taskOptions.errorHandlers(payload, context);
+            },
+        };
+        return [laravelHandler, errorHandler];
+    }
+    /**
+     * Handles the completion of the task
+     */
+    handleTaskCompletion(data, currentErrors, handlers, notification, isError = false) {
+        const errorContext = {
+            error: data,
+            errors: currentErrors.value || new Map(),
+            i18n: this.i18n,
+        };
+        const successContext = { result: data };
+        if (Array.isArray(handlers)) {
+            for (const handler of handlers) {
+                const handlerKey = getSafe(data, handler.key ?? '');
+                if (handlerKey !== undefined && (!handler.matcher || handler.matcher(handlerKey))) {
+                    if (isError) {
+                        handler.callback(data, errorContext);
+                    }
+                    else {
+                        handler.callback(data, successContext);
+                    }
+                }
+            }
+        }
+        else {
+            if (isError) {
+                if (typeof handlers === 'function') {
+                    handlers(data, errorContext);
+                }
+            }
+            else {
+                handlers?.(data);
+            }
+        }
+        void this.showResolvedNotification(notification, isError);
+    }
+    /**
+     * Shows a notification based on the resolved notification value
+     */
+    async showResolvedNotification(notification, isError) {
+        const resolvedNotification = await resolveValue(notification);
+        if (resolvedNotification === true) {
+            showNotification(isError ? 'negative' : 'positive', isError ? this.i18n.t('common.task.error') : this.i18n.t('common.task.success'));
+            return;
+        }
+        if (typeof resolvedNotification === 'string') {
+            showNotification(isError ? 'negative' : 'positive', resolvedNotification);
+            return;
+        }
+    }
+}

package/dist/services/ThemeService.d.ts

@@ -0,0 +1,28 @@
+import type { QSsrContext } from '@quasar/app-vite';
+import type { AppConfig } from '../types/app.types.js';
+import { Service } from './Service.js';
+import { type ThemeOptions } from '../types/theme.types.js';
+/**
+ * Theme Service for managing application theme
+ */
+export declare class ThemeService extends Service {
+    private currentTheme;
+    constructor(config: AppConfig, ssrContext?: QSsrContext | null);
+    /**
+     * Loads the theme from cookies or system preference
+     */
+    private loadTheme;
+    /**
+     * Get the current theme
+     */
+    get theme(): ThemeOptions;
+    /**
+     * Set theme
+     */
+    setTheme(theme: ThemeOptions): void;
+    /**
+     * Toggle theme between light and dark
+     */
+    toggleTheme(): void;
+}
+//# sourceMappingURL=ThemeService.d.ts.map

package/dist/services/ThemeService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThemeService.d.ts","sourceRoot":"","sources":["../../src/services/ThemeService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAmC,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE7F;;GAEG;AACH,qBAAa,YAAa,SAAQ,OAAO;IACvC,OAAO,CAAC,YAAY,CAAyB;gBAEjC,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI;IAqB9D;;OAEG;IACH,OAAO,CAAC,SAAS;IAyBjB;;OAEG;IACH,IAAI,KAAK,IAAI,YAAY,CAExB;IAED;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI;IAiBnC;;OAEG;IACH,WAAW,IAAI,IAAI;CAKpB"}

package/dist/services/ThemeService.js

@@ -0,0 +1,77 @@
+import { Dark, Cookies } from 'quasar';
+import { Service } from './Service.js';
+import { THEME_COOKIE_NAME, themeOptions } from '../types/theme.types.js';
+/**
+ * Theme Service for managing application theme
+ */
+export class ThemeService extends Service {
+    currentTheme = 'light';
+    constructor(config, ssrContext) {
+        super(config, ssrContext);
+        this.currentTheme = this.loadTheme(ssrContext);
+        if (ssrContext?.$q) {
+            ssrContext.$q.dark.set(this.currentTheme === 'dark');
+        }
+        if (typeof window !== 'undefined' && typeof document !== 'undefined') {
+            const root = document.documentElement;
+            Dark.set(this.currentTheme === 'dark');
+            if (this.currentTheme === 'dark') {
+                root.classList.add('dark');
+            }
+            else {
+                root.classList.remove('dark');
+            }
+        }
+    }
+    /**
+     * Loads the theme from cookies or system preference
+     */
+    loadTheme(ssrContext) {
+        if (ssrContext) {
+            const cookies = Cookies.parseSSR(ssrContext);
+            const userTheme = cookies.get(THEME_COOKIE_NAME);
+            if (userTheme && themeOptions.includes(userTheme)) {
+                return userTheme;
+            }
+            return 'light';
+        }
+        if (typeof window !== 'undefined') {
+            const userTheme = Cookies.get(THEME_COOKIE_NAME);
+            if (userTheme && themeOptions.includes(userTheme)) {
+                return userTheme;
+            }
+            return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+        }
+        return 'light';
+    }
+    /**
+     * Get the current theme
+     */
+    get theme() {
+        return this.currentTheme;
+    }
+    /**
+     * Set theme
+     */
+    setTheme(theme) {
+        if (typeof window === 'undefined')
+            return;
+        this.currentTheme = theme;
+        Cookies.set(THEME_COOKIE_NAME, theme);
+        Dark.set(theme === 'dark');
+        const root = document.documentElement;
+        if (theme === 'dark') {
+            root.classList.add('dark');
+        }
+        else {
+            root.classList.remove('dark');
+        }
+    }
+    /**
+     * Toggle theme between light and dark
+     */
+    toggleTheme() {
+        const newTheme = this.currentTheme === 'dark' ? 'light' : 'dark';
+        this.setTheme(newTheme);
+    }
+}

package/dist/services/ValidationService.d.ts

@@ -0,0 +1,55 @@
+import type { QSsrContext } from '@quasar/app-vite';
+import type { AppConfig } from '../types/app.types.js';
+import * as z from 'zod/v4';
+import type { ServiceContainer } from '../container/ServiceContainer.js';
+import type { RegisterService } from '../container/types.js';
+import { Service } from './Service.js';
+/**
+ * Default locale mapping for validation
+ * Maps common locale codes to Zod v4 locale codes
+ */
+export declare const DEFAULT_LOCALE_MAPPING: Record<string, string>;
+/**
+ * Validation Service with Zod v4 locale integration
+ */
+export declare class ValidationService extends Service implements RegisterService {
+    private static localeMapping;
+    private i18n;
+    private currentLocale;
+    /**
+     * Set custom locale mapping for validation
+     * Optional - uses DEFAULT_LOCALE_MAPPING if not called
+     *
+     * @param mapping - Locale mapping (e.g., { 'en-US': 'en', 'es-MX': 'es' })
+     */
+    static setLocaleMapping(mapping: Record<string, string>): void;
+    constructor(config: AppConfig, ssrContext?: QSsrContext | null);
+    /**
+     * Register with container - inject dependencies and set initial locale
+     */
+    register({ i18n }: ServiceContainer): void;
+    /**
+     * Set Zod validation locale based on language code
+     * Uses the locale mapping configured via setLocaleMapping()
+     */
+    setLocale(locale: string): void;
+    /**
+     * Validates a value using Zod v4's built-in locale system
+     *
+     * @param value - The value to validate
+     * @param schema - The Zod schema
+     * @param firstOnly - If true, returns first error; if false, returns all errors
+     * @returns The first error (string | true) or all errors (string[])
+     */
+    validate<T>(value: unknown, schema: z.ZodSchema<T>, firstOnly: true): string | true;
+    validate<T>(value: unknown, schema: z.ZodSchema<T>, firstOnly: false): string[];
+    /**
+     * Creates a Quasar-compatible validation rule that stops at the first error
+     * This is the recommended way to create validation rules for QInput
+     *
+     * @param schema - The Zod schema
+     * @returns A Quasar validation rule function
+     */
+    createInputRule<T>(schema: z.ZodSchema<T>): (value: unknown) => string | true;
+}
+//# sourceMappingURL=ValidationService.d.ts.map

package/dist/services/ValidationService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValidationService.d.ts","sourceRoot":"","sources":["../../src/services/ValidationService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAGvC;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAOzD,CAAC;AAEF;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,OAAQ,YAAW,eAAe;IACvE,OAAO,CAAC,MAAM,CAAC,aAAa,CAAkD;IAC9E,OAAO,CAAC,IAAI,CAAe;IAC3B,OAAO,CAAC,aAAa,CAAgB;IAErC;;;;;OAKG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;gBAIlD,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI;IAI9D;;OAEG;IACH,QAAQ,CAAC,EAAE,IAAI,EAAE,EAAE,gBAAgB,GAAG,IAAI;IAK1C;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAgB/B;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EACR,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,IAAI,GACd,MAAM,GAAG,IAAI;IAChB,QAAQ,CAAC,CAAC,EACR,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,KAAK,GACf,MAAM,EAAE;IAsBX;;;;;;OAMG;IACH,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,GAAG,IAAI;CAG9E"}