@quvel-kit/core 1.1.0

package/dist/composables/useUrlQueryHandler.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Options for the URL query handler
+ */
+export interface UrlQueryHandlerOptions<T = Record<string, string>> {
+    /** Parameters to extract from the URL query */
+    params: string[];
+    /** Validation function to check if the extracted parameters meet certain criteria */
+    validate?: (params: T) => boolean;
+    /** Whether to clean up the URL by removing the extracted parameters (default: true) */
+    cleanupUrl?: boolean;
+    /** Whether to run the handler only once (default: true) */
+    runOnce?: boolean;
+    /** Callback function to execute when the parameters are found and validated */
+    onMatch?: (params: T) => void;
+}
+/**
+ * A composable for handling URL query parameters
+ *
+ * Provides a generic way to extract, validate, and act on URL query parameters.
+ * Useful for handling authentication tokens, password resets, invitation links, etc.
+ *
+ * @example
+ * ```ts
+ * // Handle password reset token
+ * const { params } = useUrlQueryHandler({
+ *   params: ['token', 'email'],
+ *   validate: (p) => p.token.length > 10,
+ *   onMatch: (p) => {
+ *     console.log('Reset token:', p.token);
+ *   }
+ * });
+ * ```
+ */
+export declare function useUrlQueryHandler<T = Record<string, string>>(options: UrlQueryHandlerOptions<T>): {
+    params: [T] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<T, import("vue").Ref<T, T>, T> : import("vue").Ref<import("vue").UnwrapRef<T>, T | import("vue").UnwrapRef<T>>;
+    checkUrlParams: () => boolean;
+};
+//# sourceMappingURL=useUrlQueryHandler.d.ts.map

package/dist/composables/useUrlQueryHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUrlQueryHandler.d.ts","sourceRoot":"","sources":["../../src/composables/useUrlQueryHandler.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,sBAAsB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAChE,+CAA+C;IAC/C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC;IAClC,uFAAuF;IACvF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,+EAA+E;IAC/E,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,sBAAsB,CAAC,CAAC,CAAC;;0BASpE,OAAO;EA2DnC"}

package/dist/composables/useUrlQueryHandler.js

@@ -0,0 +1,76 @@
+import { onMounted, ref } from 'vue';
+/**
+ * A composable for handling URL query parameters
+ *
+ * Provides a generic way to extract, validate, and act on URL query parameters.
+ * Useful for handling authentication tokens, password resets, invitation links, etc.
+ *
+ * @example
+ * ```ts
+ * // Handle password reset token
+ * const { params } = useUrlQueryHandler({
+ *   params: ['token', 'email'],
+ *   validate: (p) => p.token.length > 10,
+ *   onMatch: (p) => {
+ *     console.log('Reset token:', p.token);
+ *   }
+ * });
+ * ```
+ */
+export function useUrlQueryHandler(options) {
+    const { params, validate = () => true, cleanupUrl = true, runOnce = true, onMatch } = options;
+    const hasRun = ref(false);
+    const extractedParams = ref({});
+    /**
+     * Extracts and processes query parameters from the URL
+     */
+    function checkUrlParams() {
+        if (runOnce && hasRun.value) {
+            return false;
+        }
+        const urlParams = new URLSearchParams(window.location.search);
+        const extractedValues = {};
+        // Extract all requested parameters
+        let allParamsFound = true;
+        for (const param of params) {
+            const value = urlParams.get(param);
+            if (value) {
+                extractedValues[param] = value;
+            }
+            else {
+                allParamsFound = false;
+            }
+        }
+        if (!allParamsFound) {
+            return false;
+        }
+        // Validate the extracted parameters
+        if (!validate(extractedValues)) {
+            return false;
+        }
+        // Store the extracted parameters
+        extractedParams.value = extractedValues;
+        // Clean up the URL if requested
+        if (cleanupUrl && window.history && window.history.replaceState) {
+            const newUrl = new URL(window.location.href);
+            params.forEach((param) => {
+                newUrl.searchParams.delete(param);
+            });
+            window.history.replaceState({}, document.title, newUrl.pathname + newUrl.search);
+        }
+        // Execute the callback if provided
+        if (onMatch) {
+            onMatch(extractedValues);
+        }
+        hasRun.value = true;
+        return true;
+    }
+    // Check URL parameters on component mount
+    onMounted(() => {
+        checkUrlParams();
+    });
+    return {
+        params: extractedParams,
+        checkUrlParams,
+    };
+}

package/dist/composables/useWebSockets.d.ts

@@ -0,0 +1,18 @@
+/**
+ * useWebSockets Composable
+ *
+ * Composable wrapper for WebSocket operations using the WebSocketService
+ */
+import type { SubscribeOptions, AnyChannel } from '../types/websocket.types.js';
+/**
+ * Composable for WebSocket operations
+ *
+ * Provides convenient methods for subscribing to and managing WebSocket channels
+ *
+ * @returns Object with subscribe and unsubscribe methods
+ */
+export declare function useWebSockets(): {
+    subscribe: <T = unknown>(options: SubscribeOptions<T>) => Promise<AnyChannel>;
+    unsubscribe: (channel: AnyChannel) => void;
+};
+//# sourceMappingURL=useWebSockets.d.ts.map

package/dist/composables/useWebSockets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWebSockets.d.ts","sourceRoot":"","sources":["../../src/composables/useWebSockets.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAGhF;;;;;;GAMG;AACH,wBAAgB,aAAa;gBASF,CAAC,qBAAqB,gBAAgB,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,UAAU,CAAC;2BA2B1D,UAAU,KAAG,IAAI;EAUhD"}

package/dist/composables/useWebSockets.js

@@ -0,0 +1,55 @@
+/**
+ * useWebSockets Composable
+ *
+ * Composable wrapper for WebSocket operations using the WebSocketService
+ */
+import { useQuvel } from './useQuvel.js';
+/**
+ * Composable for WebSocket operations
+ *
+ * Provides convenient methods for subscribing to and managing WebSocket channels
+ *
+ * @returns Object with subscribe and unsubscribe methods
+ */
+export function useWebSockets() {
+    const { ws } = useQuvel();
+    /**
+     * Subscribe to a WebSocket channel
+     *
+     * @param options - Channel subscription options
+     * @returns The channel object
+     */
+    async function subscribe(options) {
+        let channel;
+        if (options.type === 'public' || options.type === 'publicNotification') {
+            channel = await ws.subscribe(options);
+        }
+        else if (options.type === 'private' || options.type === 'privateNotification') {
+            channel = await ws.subscribe(options);
+        }
+        else if (options.type === 'presence') {
+            channel = await ws.subscribe(options);
+        }
+        else if (options.type === 'encrypted') {
+            channel = await ws.subscribe(options);
+        }
+        else {
+            throw new Error(`Unsupported channel type: ${String(options.type)}`);
+        }
+        return channel;
+    }
+    /**
+     * Unsubscribe from a channel
+     *
+     * @param channel - The channel to unsubscribe from
+     */
+    function unsubscribe(channel) {
+        if (channel) {
+            channel.unsubscribe();
+        }
+    }
+    return {
+        subscribe,
+        unsubscribe,
+    };
+}

package/dist/composables/useWindowEvent.d.ts

@@ -0,0 +1,16 @@
+/**
+ * useWindowEvent Composable
+ *
+ * A Vue 3 composable for safely adding and removing window event listeners.
+ * Ensures that event listeners are only added on the client-side and are
+ * automatically cleaned up when the component is unmounted.
+ */
+/**
+ * Safely adds a window event listener and cleans it up on unmount
+ *
+ * @param eventType - The type of event to listen for (e.g., 'scroll', 'resize')
+ * @param handler - The function to call when the event is triggered
+ * @param options - Optional event listener options
+ */
+export declare function useWindowEvent(eventType: string, handler: () => void, options?: boolean | AddEventListenerOptions): void;
+//# sourceMappingURL=useWindowEvent.d.ts.map

package/dist/composables/useWindowEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWindowEvent.d.ts","sourceRoot":"","sources":["../../src/composables/useWindowEvent.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,IAAI,EACnB,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAC1C,IAAI,CAYN"}

package/dist/composables/useWindowEvent.js

@@ -0,0 +1,27 @@
+/**
+ * useWindowEvent Composable
+ *
+ * A Vue 3 composable for safely adding and removing window event listeners.
+ * Ensures that event listeners are only added on the client-side and are
+ * automatically cleaned up when the component is unmounted.
+ */
+import { onMounted, onUnmounted } from 'vue';
+/**
+ * Safely adds a window event listener and cleans it up on unmount
+ *
+ * @param eventType - The type of event to listen for (e.g., 'scroll', 'resize')
+ * @param handler - The function to call when the event is triggered
+ * @param options - Optional event listener options
+ */
+export function useWindowEvent(eventType, handler, options) {
+    onMounted(() => {
+        if (typeof window !== 'undefined') {
+            window.addEventListener(eventType, handler, options);
+        }
+    });
+    onUnmounted(() => {
+        if (typeof window !== 'undefined') {
+            window.removeEventListener(eventType, handler, options);
+        }
+    });
+}

package/dist/composables/useXsrf.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Options for fetchXsrf function
+ */
+export interface FetchXsrfOptions {
+    /**
+     * Force XSRF token fetch even without an existing session
+     */
+    force?: boolean;
+}
+/**
+ * Composable that returns a function to fetch XSRF token on demand
+ *
+ * Use this in auth dialogs to fetch the XSRF token when the dialog opens,
+ * not when the component mounts.
+ *
+ * @example
+ * ```ts
+ * // In AuthDialog.vue
+ * const { fetchXsrf } = useXsrf();
+ *
+ * function handleBeforeShow() {
+ *   fetchXsrf({ force: true }); // Call when dialog opens
+ * }
+ * ```
+ */
+export declare function useXsrf(): {
+    fetchXsrf: (options?: FetchXsrfOptions) => void;
+};
+//# sourceMappingURL=useXsrf.d.ts.map

package/dist/composables/useXsrf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useXsrf.d.ts","sourceRoot":"","sources":["../../src/composables/useXsrf.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,IAAI;IAAE,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,IAAI,CAAA;CAAE,CA2C7E"}

package/dist/composables/useXsrf.js

@@ -0,0 +1,59 @@
+import { useQuasar } from 'quasar';
+import { useQuvel } from './useQuvel.js';
+/**
+ * Default XSRF cookie name
+ */
+const XSRF_COOKIE_NAME = 'XSRF-TOKEN';
+/**
+ * Composable that returns a function to fetch XSRF token on demand
+ *
+ * Use this in auth dialogs to fetch the XSRF token when the dialog opens,
+ * not when the component mounts.
+ *
+ * @example
+ * ```ts
+ * // In AuthDialog.vue
+ * const { fetchXsrf } = useXsrf();
+ *
+ * function handleBeforeShow() {
+ *   fetchXsrf({ force: true }); // Call when dialog opens
+ * }
+ * ```
+ */
+export function useXsrf() {
+    const $q = useQuasar();
+    const { config, api } = useQuvel();
+    /**
+     * Fetch XSRF token if not already set
+     *
+     * @param options - Configuration options
+     * @param options.force - Force token fetch even without session (for login/register flows)
+     */
+    function fetchXsrf(options = {}) {
+        if (!options.force && !api.hasSession()) {
+            return;
+        }
+        const cookieName = config.session?.xsrf_cookie
+            || (config.tenant?.id ? `tenant_${config.tenant.id}_xsrf` : XSRF_COOKIE_NAME);
+        let xsrf = $q.cookies.get(cookieName);
+        if (xsrf === null && typeof document !== 'undefined') {
+            const cookies = document.cookie.split(';');
+            const cookie = cookies.find(c => c.trim().startsWith(`${cookieName}=`));
+            if (cookie) {
+                xsrf = cookie.split('=')[1] ?? null;
+            }
+            if (xsrf !== null) {
+                return;
+            }
+            try {
+                void api.get('/sanctum/csrf-cookie');
+            }
+            catch {
+                // Silently fail on error
+            }
+        }
+    }
+    return {
+        fetchXsrf,
+    };
+}

package/dist/config/QuasarConfigBuilder.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Quasar Configuration Builder
+ *
+ * Type-safe builder for constructing Quasar application configurations
+ * with support for different build modes (SPA, SSR, PWA, Capacitor, Electron)
+ */
+import type { ConfigureCallback } from '@quasar/app-vite';
+export type QuasarContext = Parameters<ConfigureCallback>[0];
+export type QuasarConfig = ReturnType<ConfigureCallback>;
+/**
+ * Configuration callback function
+ */
+export type ConfigCallback = (ctx: QuasarContext) => QuasarConfig | Promise<QuasarConfig>;
+/**
+ * Mode-specific configuration map
+ */
+export type ModeConfigMap = Partial<Record<QuasarMode, ConfigCallback>>;
+/**
+ * Supported Quasar build modes
+ */
+export type QuasarMode = 'spa' | 'ssr' | 'pwa' | 'capacitor' | 'electron';
+/**
+ * Configuration builder options
+ */
+export interface QuasarConfigBuilderOptions {
+    /** Common configuration applied to all modes */
+    common?: ConfigCallback;
+    /** Mode-specific configurations */
+    modes?: ModeConfigMap;
+    /** Additional config transformers to apply */
+    transformers?: ConfigTransformer[];
+}
+/**
+ * Unwrapped Quasar config object
+ */
+export type QuasarConf = Awaited<QuasarConfig>;
+/**
+ * Configuration transformer function
+ */
+export type ConfigTransformer = (config: QuasarConf, ctx: QuasarContext) => QuasarConf | Promise<QuasarConf>;
+/**
+ * Quasar Configuration Builder
+ *
+ * Provides a fluent API for building Quasar configurations with
+ * common base config and mode-specific overrides.
+ *
+ * @example
+ * ```ts
+ * const builder = new QuasarConfigBuilder()
+ *   .setCommon((ctx) => ({
+ *     boot: ['app'],
+ *     css: ['app.scss']
+ *   }))
+ *   .setMode('ssr', (ctx) => ({
+ *     ssr: {
+ *       pwa: false
+ *     }
+ *   }))
+ *   .addTransformer((config, ctx) => {
+ *     // Custom transformation
+ *     return config;
+ *   });
+ *
+ * export default builder.build();
+ * ```
+ */
+export declare class QuasarConfigBuilder {
+    private commonConfig?;
+    private modeConfigs;
+    private transformers;
+    /**
+     * Set a common configuration applied to all modes
+     */
+    setCommon(config: ConfigCallback): this;
+    /**
+     * Set mode-specific configuration
+     */
+    setMode(mode: QuasarMode, config: ConfigCallback): this;
+    /**
+     * Set multiple mode configurations at once
+     */
+    setModes(modes: ModeConfigMap): this;
+    /**
+     * Add a configuration transformer
+     *
+     * Transformers are applied after merging common and mode configs
+     */
+    addTransformer(transformer: ConfigTransformer): this;
+    /**
+     * Add multiple transformers
+     */
+    addTransformers(transformers: ConfigTransformer[]): this;
+    /**
+     * Build the final configuration function
+     *
+     * Returns a Quasar-compatible configuration function
+     */
+    build(): ConfigureCallback;
+}
+//# sourceMappingURL=QuasarConfigBuilder.d.ts.map

package/dist/config/QuasarConfigBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuasarConfigBuilder.d.ts","sourceRoot":"","sources":["../../src/config/QuasarConfigBuilder.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAG1D,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7D,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,aAAa,KAAK,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAE1F;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;AAExE;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,gDAAgD;IAChD,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,mCAAmC;IACnC,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,8CAA8C;IAC9C,YAAY,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAE/C;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,aAAa,KACf,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,YAAY,CAAC,CAAiB;IACtC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,YAAY,CAA2B;IAE/C;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAKvC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI;IAKvD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAKpC;;;;OAIG;IACH,cAAc,CAAC,WAAW,EAAE,iBAAiB,GAAG,IAAI;IAKpD;;OAEG;IACH,eAAe,CAAC,YAAY,EAAE,iBAAiB,EAAE,GAAG,IAAI;IAKxD;;;;OAIG;IACH,KAAK,IAAI,iBAAiB;CAuB3B"}

package/dist/config/QuasarConfigBuilder.js

@@ -0,0 +1,98 @@
+/**
+ * Quasar Configuration Builder
+ *
+ * Type-safe builder for constructing Quasar application configurations
+ * with support for different build modes (SPA, SSR, PWA, Capacitor, Electron)
+ */
+import { deepMerge } from '../utils/deepMerge.js';
+/**
+ * Quasar Configuration Builder
+ *
+ * Provides a fluent API for building Quasar configurations with
+ * common base config and mode-specific overrides.
+ *
+ * @example
+ * ```ts
+ * const builder = new QuasarConfigBuilder()
+ *   .setCommon((ctx) => ({
+ *     boot: ['app'],
+ *     css: ['app.scss']
+ *   }))
+ *   .setMode('ssr', (ctx) => ({
+ *     ssr: {
+ *       pwa: false
+ *     }
+ *   }))
+ *   .addTransformer((config, ctx) => {
+ *     // Custom transformation
+ *     return config;
+ *   });
+ *
+ * export default builder.build();
+ * ```
+ */
+export class QuasarConfigBuilder {
+    commonConfig;
+    modeConfigs = {};
+    transformers = [];
+    /**
+     * Set a common configuration applied to all modes
+     */
+    setCommon(config) {
+        this.commonConfig = config;
+        return this;
+    }
+    /**
+     * Set mode-specific configuration
+     */
+    setMode(mode, config) {
+        this.modeConfigs[mode] = config;
+        return this;
+    }
+    /**
+     * Set multiple mode configurations at once
+     */
+    setModes(modes) {
+        Object.assign(this.modeConfigs, modes);
+        return this;
+    }
+    /**
+     * Add a configuration transformer
+     *
+     * Transformers are applied after merging common and mode configs
+     */
+    addTransformer(transformer) {
+        this.transformers.push(transformer);
+        return this;
+    }
+    /**
+     * Add multiple transformers
+     */
+    addTransformers(transformers) {
+        this.transformers.push(...transformers);
+        return this;
+    }
+    /**
+     * Build the final configuration function
+     *
+     * Returns a Quasar-compatible configuration function
+     */
+    build() {
+        return async (ctx) => {
+            let config = {};
+            if (this.commonConfig) {
+                const commonResult = await this.commonConfig(ctx);
+                config = deepMerge(config, commonResult);
+            }
+            const modeConfig = this.modeConfigs[ctx.modeName];
+            if (modeConfig) {
+                const modeResult = await modeConfig(ctx);
+                config = deepMerge(config, modeResult);
+            }
+            for (const transformer of this.transformers) {
+                config = await transformer(config, ctx);
+            }
+            return config;
+        };
+    }
+}

package/dist/config/i18n.d.ts

@@ -0,0 +1,23 @@
+/**
+ * I18n Configuration Helpers
+ *
+ * Centralized i18n configuration that reads from AppConfig
+ */
+import type { AppConfig } from '../types/app.types.js';
+/**
+ * Get supported locales
+ */
+export declare function getSupportedLocales(_config?: AppConfig): string[];
+/**
+ * Get the default locale from config or use default
+ */
+export declare function getDefaultLocale(config?: AppConfig): string;
+/**
+ * Get the locale cookie key
+ */
+export declare function getLocaleCookieKey(config?: AppConfig): string;
+/**
+ * Validate if a locale is supported
+ */
+export declare function isValidLocale(locale: string, config?: AppConfig): boolean;
+//# sourceMappingURL=i18n.d.ts.map

package/dist/config/i18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/config/i18n.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CAWjE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,MAAM,CAK3D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,MAAM,CAK7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,GAAG,OAAO,CAGzE"}

package/dist/config/i18n.js

@@ -0,0 +1,43 @@
+/**
+ * I18n Configuration Helpers
+ *
+ * Centralized i18n configuration that reads from AppConfig
+ */
+/**
+ * Get supported locales
+ */
+export function getSupportedLocales(_config) {
+    const env = (typeof import.meta !== 'undefined' && import.meta.env)
+        ? import.meta.env
+        : (typeof process !== 'undefined' ? process.env : {});
+    const locales = env.VITE_ALLOWED_LOCALES;
+    if (locales && typeof locales === 'string') {
+        return locales.split(',').map((l) => l.trim()).filter(Boolean);
+    }
+    return ['en-US', 'es-MX'];
+}
+/**
+ * Get the default locale from config or use default
+ */
+export function getDefaultLocale(config) {
+    const env = (typeof import.meta !== 'undefined' && import.meta.env)
+        ? import.meta.env
+        : (typeof process !== 'undefined' ? process.env : {});
+    return config?.app?.locale || config?.app?.fallback_locale || env.VITE_LOCALE || 'en-US';
+}
+/**
+ * Get the locale cookie key
+ */
+export function getLocaleCookieKey(config) {
+    const env = (typeof import.meta !== 'undefined' && import.meta.env)
+        ? import.meta.env
+        : (typeof process !== 'undefined' ? process.env : {});
+    return config?.i18nCookie || env.VITE_I18N_COOKIE || 'user-locale';
+}
+/**
+ * Validate if a locale is supported
+ */
+export function isValidLocale(locale, config) {
+    const supported = getSupportedLocales(config);
+    return supported.includes(locale);
+}

package/dist/config/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Configuration Module
+ *
+ * Exports configuration builders and utilities for Quasar applications
+ */
+export { QuasarConfigBuilder, type ConfigCallback, type ModeConfigMap, type QuasarMode, type QuasarConfigBuilderOptions, type ConfigTransformer, type QuasarConfig, type QuasarConf, } from './QuasarConfigBuilder.js';
+export { getSupportedLocales, getDefaultLocale, getLocaleCookieKey } from './i18n.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,0BAA0B,EAC/B,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,UAAU,GAChB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,7 @@
+/**
+ * Configuration Module
+ *
+ * Exports configuration builders and utilities for Quasar applications
+ */
+export { QuasarConfigBuilder, } from './QuasarConfigBuilder.js';
+export { getSupportedLocales, getDefaultLocale, getLocaleCookieKey } from './i18n.js';

package/dist/config/moduleTransformer.d.ts

@@ -0,0 +1,18 @@
+import type { ConfigTransformer } from './QuasarConfigBuilder.js';
+import type { Module } from '../modules/types.js';
+/**
+ * Create a config transformer that applies all module build configs
+ *
+ * This utility is for build-time only and should be imported in quasar.config.ts
+ *
+ * @example
+ * ```ts
+ * import { createModuleTransformer } from '@quvel-kit/core/config/moduleTransformer';
+ *
+ * new QuasarConfigBuilder()
+ *   .addTransformer(createModuleTransformer(modules))
+ *   .build();
+ * ```
+ */
+export declare function createModuleTransformer(modules: Module[]): ConfigTransformer;
+//# sourceMappingURL=moduleTransformer.d.ts.map

package/dist/config/moduleTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moduleTransformer.d.ts","sourceRoot":"","sources":["../../src/config/moduleTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAoC,MAAM,qBAAqB,CAAC;AA+CpF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,iBAAiB,CA+B5E"}