@quvel-kit/core 1.1.0

package/dist/utils/assets.js

@@ -0,0 +1,340 @@
+/**
+ * Asset Loading Utilities
+ *
+ * Helper functions for dynamically loading CSS and JS assets
+ * Support both client-side and SSR asset injection
+ */
+/**
+ * Validates if a URL is safe to load as an asset
+ * Prevents loading from potentially malicious sources
+ */
+export function isValidAssetUrl(url) {
+    try {
+        // Allow relative URLs
+        if (url.startsWith('/')) {
+            return true;
+        }
+        const parsedUrl = new URL(url);
+        // Only allow HTTPS in production
+        if (import.meta.env.MODE === 'production' && parsedUrl.protocol !== 'https:') {
+            return false;
+        }
+        // Allow HTTP/HTTPS
+        if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+            return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Sanitizes inline content to prevent XSS attacks
+ * Basic implementation - consider using DOMPurify for more robust protection
+ */
+export function sanitizeInlineContent(content) {
+    // Remove script tags and event handlers
+    return content
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+        .replace(/on\w+\s*=\s*"[^"]*"/gi, '')
+        .replace(/on\w+\s*=\s*'[^']*'/gi, '')
+        .replace(/javascript:/gi, '');
+}
+/**
+ * Creates a CSS link or style element from configuration
+ */
+export function createCSSElement(config) {
+    if (config.url) {
+        if (!isValidAssetUrl(config.url)) {
+            console.warn('Invalid CSS URL:', config.url);
+            return null;
+        }
+        const link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.href = config.url;
+        if (config.media) {
+            link.media = config.media;
+        }
+        if (config.integrity) {
+            link.integrity = config.integrity;
+        }
+        if (config.crossorigin) {
+            link.crossOrigin = config.crossorigin;
+        }
+        // Handle loading priority for CSS
+        if (config.priority === 'critical') {
+            link.rel = 'preload';
+            link.as = 'style';
+            link.onload = () => {
+                link.rel = 'stylesheet';
+            };
+        }
+        else if (config.priority === 'low') {
+            link.media = 'print';
+            link.onload = () => {
+                link.media = config.media || 'all';
+            };
+        }
+        return link;
+    }
+    else if (config.inline) {
+        const style = document.createElement('style');
+        style.textContent = sanitizeInlineContent(config.inline);
+        if (config.priority) {
+            style.setAttribute('data-priority', config.priority);
+        }
+        return style;
+    }
+    return null;
+}
+/**
+ * Creates a JavaScript script element from configuration
+ */
+export function createJSElement(config) {
+    const script = document.createElement('script');
+    if (config.url) {
+        if (!isValidAssetUrl(config.url)) {
+            console.warn('Invalid JS URL:', config.url);
+            return null;
+        }
+        script.src = config.url;
+        if (config.integrity) {
+            script.integrity = config.integrity;
+        }
+        if (config.crossorigin) {
+            script.crossOrigin = config.crossorigin;
+        }
+    }
+    else if (config.inline) {
+        script.textContent = sanitizeInlineContent(config.inline);
+    }
+    else {
+        return null;
+    }
+    if (config.loading === 'immediate') {
+        // No defer/async - loads and executes immediately
+    }
+    else if (config.loading === 'deferred') {
+        script.defer = true;
+    }
+    else if (config.loading === 'lazy') {
+        script.async = true;
+    }
+    else {
+        if (config.defer) {
+            script.defer = true;
+        }
+        if (config.async) {
+            script.async = true;
+        }
+    }
+    if (config.priority) {
+        script.setAttribute('data-priority', config.priority);
+    }
+    if (config.position) {
+        script.setAttribute('data-position', config.position);
+    }
+    return script;
+}
+/**
+ * Injects an element at the specified position in the document
+ */
+function injectElementAtPosition(element, position) {
+    switch (position) {
+        case 'head':
+            document.head.appendChild(element);
+            break;
+        case 'body-start':
+            if (document.body.firstChild) {
+                document.body.insertBefore(element, document.body.firstChild);
+            }
+            else {
+                document.body.appendChild(element);
+            }
+            break;
+        case 'body-end':
+        default:
+            document.body.appendChild(element);
+            break;
+    }
+}
+/**
+ * Injects app assets into the document
+ * Used by client-side asset loading (non-SSR modes)
+ */
+export function injectAssets(assets) {
+    if (!assets)
+        return;
+    // Sort and inject CSS assets by priority
+    if (assets.css?.length) {
+        const sortedCSS = [...assets.css].sort((a, b) => {
+            const priorityOrder = { critical: 0, normal: 1, low: 2 };
+            const aPriority = priorityOrder[a.priority || 'normal'];
+            const bPriority = priorityOrder[b.priority || 'normal'];
+            return aPriority - bPriority;
+        });
+        sortedCSS.forEach((cssConfig) => {
+            const element = createCSSElement(cssConfig);
+            if (element) {
+                const position = cssConfig.position || 'head';
+                injectElementAtPosition(element, position);
+            }
+        });
+    }
+    if (assets.js?.length) {
+        const sortedJS = [...assets.js].sort((a, b) => {
+            const priorityOrder = { critical: 0, normal: 1, low: 2 };
+            const loadingOrder = { immediate: 0, deferred: 1, lazy: 2 };
+            const aPriority = priorityOrder[a.priority || 'normal'];
+            const bPriority = priorityOrder[b.priority || 'normal'];
+            if (aPriority !== bPriority)
+                return aPriority - bPriority;
+            const aLoading = loadingOrder[a.loading || 'deferred'];
+            const bLoading = loadingOrder[b.loading || 'deferred'];
+            return aLoading - bLoading;
+        });
+        const immediateScripts = sortedJS.filter((js) => js.loading === 'immediate');
+        const deferredScripts = sortedJS.filter((js) => js.loading !== 'immediate');
+        immediateScripts.forEach((jsConfig) => {
+            const element = createJSElement(jsConfig);
+            if (element) {
+                const position = jsConfig.position || 'head';
+                injectElementAtPosition(element, position);
+            }
+        });
+        if (deferredScripts.length > 0) {
+            const processDeferred = () => {
+                deferredScripts.forEach((jsConfig) => {
+                    const element = createJSElement(jsConfig);
+                    if (element) {
+                        const position = jsConfig.position || 'body-end';
+                        injectElementAtPosition(element, position);
+                    }
+                });
+            };
+            if ('requestIdleCallback' in window) {
+                requestIdleCallback(processDeferred);
+            }
+            else {
+                setTimeout(processDeferred, 0);
+            }
+        }
+    }
+}
+/**
+ * Generates HTML strings for server-side asset injection
+ * Used by SSR asset injection
+ */
+export function generateAssetHTML(assets) {
+    let headHTML = '';
+    let bodyStartHTML = '';
+    let bodyEndHTML = '';
+    if (!assets) {
+        return { headHTML, bodyStartHTML, bodyEndHTML };
+    }
+    const sortedCSS = assets.css
+        ? [...assets.css].sort((a, b) => {
+            const priorityOrder = { critical: 0, normal: 1, low: 2 };
+            const aPriority = priorityOrder[a.priority || 'normal'];
+            const bPriority = priorityOrder[b.priority || 'normal'];
+            return aPriority - bPriority;
+        })
+        : [];
+    const sortedJS = assets.js
+        ? [...assets.js].sort((a, b) => {
+            const priorityOrder = { critical: 0, normal: 1, low: 2 };
+            const loadingOrder = { immediate: 0, deferred: 1, lazy: 2 };
+            const aPriority = priorityOrder[a.priority || 'normal'];
+            const bPriority = priorityOrder[b.priority || 'normal'];
+            if (aPriority !== bPriority)
+                return aPriority - bPriority;
+            const aLoading = loadingOrder[a.loading || 'deferred'];
+            const bLoading = loadingOrder[b.loading || 'deferred'];
+            return aLoading - bLoading;
+        })
+        : [];
+    sortedCSS.forEach((config) => {
+        let cssHTML = '';
+        if (config.url && isValidAssetUrl(config.url)) {
+            const attrs = [];
+            if (config.media)
+                attrs.push(`media="${config.media}"`);
+            if (config.integrity)
+                attrs.push(`integrity="${config.integrity}"`);
+            if (config.crossorigin)
+                attrs.push(`crossorigin="${config.crossorigin}"`);
+            if (config.priority)
+                attrs.push(`data-priority="${config.priority}"`);
+            if (config.priority === 'critical') {
+                cssHTML = `<link rel="preload" href="${config.url}" as="style" onload="this.rel='stylesheet'" ${attrs.join(' ')}>`;
+            }
+            else if (config.priority === 'low') {
+                cssHTML = `<link rel="stylesheet" href="${config.url}" media="print" onload="this.media='${config.media || 'all'}'" ${attrs.join(' ')}>`;
+            }
+            else {
+                cssHTML = `<link rel="stylesheet" href="${config.url}" ${attrs.join(' ')}>`;
+            }
+        }
+        else if (config.inline) {
+            const priorityAttr = config.priority ? ` data-priority="${config.priority}"` : '';
+            cssHTML = `<style${priorityAttr}>${sanitizeInlineContent(config.inline)}</style>`;
+        }
+        const position = config.position || 'head';
+        if (position === 'head') {
+            headHTML += cssHTML;
+        }
+        else if (position === 'body-start') {
+            bodyStartHTML += cssHTML;
+        }
+        else {
+            bodyEndHTML += cssHTML;
+        }
+    });
+    // Generate JS HTML
+    sortedJS.forEach((config) => {
+        let jsHTML = '';
+        if (config.url && isValidAssetUrl(config.url)) {
+            const attrs = [];
+            if (config.loading === 'immediate') {
+            }
+            else if (config.loading === 'deferred') {
+                attrs.push('defer');
+            }
+            else if (config.loading === 'lazy') {
+                attrs.push('async');
+            }
+            else {
+                if (config.defer)
+                    attrs.push('defer');
+                if (config.async)
+                    attrs.push('async');
+            }
+            if (config.integrity)
+                attrs.push(`integrity="${config.integrity}"`);
+            if (config.crossorigin)
+                attrs.push(`crossorigin="${config.crossorigin}"`);
+            if (config.priority)
+                attrs.push(`data-priority="${config.priority}"`);
+            if (config.position)
+                attrs.push(`data-position="${config.position}"`);
+            jsHTML = `<script src="${config.url}" ${attrs.join(' ')}></script>`;
+        }
+        else if (config.inline) {
+            const priorityAttr = config.priority ? ` data-priority="${config.priority}"` : '';
+            const positionAttr = config.position ? ` data-position="${config.position}"` : '';
+            jsHTML = `<script${priorityAttr}${positionAttr}>${sanitizeInlineContent(config.inline)}</script>`;
+        }
+        const position = config.position || (config.loading === 'immediate' ? 'head' : 'body-end');
+        if (position === 'head') {
+            headHTML += jsHTML;
+        }
+        else if (position === 'body-start') {
+            bodyStartHTML += jsHTML;
+        }
+        else {
+            bodyEndHTML += jsHTML;
+        }
+    });
+    return { headHTML, bodyStartHTML, bodyEndHTML };
+}

package/dist/utils/axios.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Axios Utility Functions
+ *
+ * Helper functions for creating and configuring Axios instances
+ */
+import type { AxiosInstance } from 'axios';
+import type { QSsrContext } from '@quasar/app-vite';
+import type { AppConfig } from '../types/app.types.js';
+/**
+ * Validate session token format
+ */
+export declare function isValidSessionToken(token: unknown): token is string;
+/**
+ * Create Axios instance configured for API requests
+ *
+ * Handles SSR context, XSRF tokens, session cookies, and base URL resolution
+ */
+export declare function createApiInstance(ssrContext?: QSsrContext, appConfig?: Readonly<AppConfig>): AxiosInstance;
+//# sourceMappingURL=axios.d.ts.map

package/dist/utils/axios.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axios.d.ts","sourceRoot":"","sources":["../../src/utils/axios.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAqB,MAAM,OAAO,CAAC;AAE7D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAqCrD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CASnE;AAoBD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,CAAC,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,aAAa,CAmD1G"}

package/dist/utils/axios.js

@@ -0,0 +1,113 @@
+/**
+ * Axios Utility Functions
+ *
+ * Helper functions for creating and configuring Axios instances
+ */
+import axios from 'axios';
+import { getSsrKeyHeader } from './headers.js';
+/**
+ * Get default XSRF cookie name
+ */
+function getDefaultXsrfCookieName() {
+    return import.meta.env.XSRF_COOKIE_NAME || 'XSRF-TOKEN';
+}
+/**
+ * Get default session cookie name
+ */
+function getDefaultSessionCookieName() {
+    return import.meta.env.SESSION_COOKIE_NAME || 'laravel_session';
+}
+/**
+ * Get XSRF cookie name from AppConfig or SSR context or default
+ */
+function getXsrfCookieName(appConfig, ssrContext) {
+    // Priority: AppConfig > SSR quvelContext > env default
+    return appConfig?.session?.xsrf_cookie
+        || ssrContext?.req?.quvelContext?.appConfig?.session?.xsrf_cookie
+        || getDefaultXsrfCookieName();
+}
+/**
+ * Get the session cookie name from AppConfig or SSR context or default
+ */
+function getSessionCookieName(appConfig, ssrContext) {
+    // Priority: AppConfig > SSR quvelContext > env default
+    return appConfig?.session?.cookie
+        || ssrContext?.req?.quvelContext?.appConfig?.session?.cookie
+        || getDefaultSessionCookieName();
+}
+/**
+ * Validate session token format
+ */
+export function isValidSessionToken(token) {
+    if (typeof token !== 'string')
+        return false;
+    try {
+        const decoded = decodeURIComponent(token);
+        return /^[A-Za-z0-9+/=]{20,512}$/.test(decoded);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse cookies from SSR request
+ */
+function parseSsrCookies(ssrServiceOptions) {
+    const cookieHeader = ssrServiceOptions?.req?.headers?.cookie;
+    if (!cookieHeader)
+        return {};
+    const cookies = {};
+    cookieHeader.split(';').forEach((cookie) => {
+        const [name, ...rest] = cookie.split('=');
+        if (name && rest.length > 0) {
+            cookies[name.trim()] = rest.join('=').trim();
+        }
+    });
+    return cookies;
+}
+/**
+ * Create Axios instance configured for API requests
+ *
+ * Handles SSR context, XSRF tokens, session cookies, and base URL resolution
+ */
+export function createApiInstance(ssrContext, appConfig) {
+    const baseURL = appConfig?.app?.url || import.meta.env.VITE_API_URL || '';
+    if (!baseURL) {
+        throw new Error('No API URL configured. Set VITE_API_URL or configure app.url in AppConfig');
+    }
+    const axiosConfig = {
+        baseURL,
+        withCredentials: true,
+        withXSRFToken: true,
+        xsrfCookieName: getXsrfCookieName(appConfig, ssrContext),
+        xsrfHeaderName: 'X-XSRF-TOKEN',
+        headers: {
+            Accept: 'application/json',
+        },
+    };
+    const instance = axios.create(axiosConfig);
+    // Detect session cookie presence from AppConfig
+    let hasSessionCookie = false;
+    if (ssrContext) {
+        // SSR: Set up SSR-specific headers and session detection
+        if (appConfig?.api?.ssrKey) {
+            const ssrKeyHeaderName = getSsrKeyHeader(appConfig);
+            instance.defaults.headers.common[ssrKeyHeaderName] = appConfig.api.ssrKey;
+        }
+        const sessionCookie = getSessionCookieName(appConfig, ssrContext);
+        const xsrfCookieName = getXsrfCookieName(appConfig, ssrContext);
+        const cookies = parseSsrCookies(ssrContext);
+        const sessionToken = cookies[sessionCookie];
+        const xsrfToken = cookies[xsrfCookieName];
+        instance.defaults.maxRedirects = Number(import.meta.env.SSR_AXIOS_MAX_REDIRECTS || 0);
+        instance.defaults.timeout = Number(import.meta.env.SSR_AXIOS_TIMEOUT || 5000);
+        if (isValidSessionToken(sessionToken)) {
+            instance.defaults.headers.Cookie = `${sessionCookie}=${sessionToken}`;
+            if (xsrfToken) {
+                hasSessionCookie = true;
+            }
+        }
+    }
+    instance.defaults.hasSessionCookie = hasSessionCookie;
+    return instance;
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Config utility functions
+ */
+import type { QSsrContext } from '@quasar/app-vite';
+import type { AppConfig } from '../types/app.types.js';
+/**
+ * Create app config from environment variables
+ * Works in both client (import.meta.env) and server (process.env) contexts
+ */
+export declare function createConfigFromEnv(): AppConfig;
+/**
+ * Create app config from SSR context, window, or environment variables
+ * Always starts with env baseline, then merges overrides from SSR context or window
+ */
+export declare function createConfig(ssrContext?: QSsrContext | null): AppConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,CA0B/C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAUvE"}

package/dist/utils/config.js

@@ -0,0 +1,48 @@
+/**
+ * Config utility functions
+ */
+/**
+ * Create app config from environment variables
+ * Works in both client (import.meta.env) and server (process.env) contexts
+ */
+export function createConfigFromEnv() {
+    const env = (typeof import.meta !== 'undefined' && import.meta.env)
+        ? import.meta.env
+        : (typeof process !== 'undefined' ? process.env : {});
+    const config = {
+        app: {
+            name: env.VITE_APP_NAME || 'Quasar App',
+            url: env.VITE_API_URL || '',
+            env: env.VITE_APP_ENV || undefined,
+            debug: env.VITE_DEBUG === 'true' ? true : undefined,
+            timezone: env.VITE_TIMEZONE || undefined,
+            locale: env.VITE_LOCALE || undefined,
+            fallback_locale: env.VITE_FALLBACK_LOCALE || undefined,
+        },
+        frontend: {
+            url: env.VITE_APP_URL || '',
+            custom_scheme: env.VITE_CUSTOM_SCHEME || undefined,
+        },
+        session: {
+            xsrf_cookie: env.XSRF_COOKIE_NAME || undefined,
+        },
+        i18nCookie: env.VITE_I18N_COOKIE || undefined,
+    };
+    return config;
+}
+/**
+ * Create app config from SSR context, window, or environment variables
+ * Always starts with env baseline, then merges overrides from SSR context or window
+ */
+export function createConfig(ssrContext) {
+    const baseConfig = createConfigFromEnv();
+    if (ssrContext?.req?.quvelContext?.appConfig) {
+        return { ...baseConfig, ...ssrContext.req.quvelContext.appConfig };
+    }
+    else if (typeof window !== 'undefined' && window.__APP_CONFIG__) {
+        return { ...baseConfig, ...window.__APP_CONFIG__ };
+    }
+    else {
+        return baseConfig;
+    }
+}

package/dist/utils/container.d.ts

@@ -0,0 +1,12 @@
+import type { QSsrContext } from '@quasar/app-vite';
+import { ServiceContainer } from '../container/ServiceContainer.js';
+import type { ServiceClass } from '../container/types.js';
+/**
+ * Creates the service container per request
+ *
+ * @param ssrContext - The SSR context from Quasar (if in SSR mode)
+ * @param serviceClasses - Map of service classes to instantiate
+ * @returns The fully initialized service container
+ */
+export declare function createContainer(ssrContext?: QSsrContext | null, serviceClasses?: Map<string, ServiceClass>): ServiceContainer;
+//# sourceMappingURL=container.d.ts.map

package/dist/utils/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/utils/container.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI,EAC/B,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,GACzC,gBAAgB,CAElB"}

package/dist/utils/container.js

@@ -0,0 +1,11 @@
+import { ServiceContainer } from '../container/ServiceContainer.js';
+/**
+ * Creates the service container per request
+ *
+ * @param ssrContext - The SSR context from Quasar (if in SSR mode)
+ * @param serviceClasses - Map of service classes to instantiate
+ * @returns The fully initialized service container
+ */
+export function createContainer(ssrContext, serviceClasses) {
+    return new ServiceContainer(ssrContext, serviceClasses);
+}

package/dist/utils/deepMerge.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Deep merge utility for configuration objects
+ *
+ * Recursively merges two objects with the following behavior:
+ * - Nested objects are merged recursively
+ * - Arrays are concatenated (not replaced)
+ * - Primitives from source override target
+ * - Null and undefined values are preserved
+ *
+ * @example
+ * ```ts
+ * const base = { plugins: ['A'], options: { debug: true } };
+ * const override = { plugins: ['B'], options: { verbose: true } };
+ * deepMerge(base, override);
+ * // Result: { plugins: ['A', 'B'], options: { debug: true, verbose: true } }
+ * ```
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(target: T, source: Partial<T>): T;
+/**
+ * Merge multiple configuration objects from left to right
+ *
+ * @example
+ * ```ts
+ * const merged = mergeConfigs(base, mode, module, override);
+ * ```
+ */
+export declare function mergeConfigs<T extends Record<string, unknown>>(...configs: Array<Partial<T> | T>): T;
+//# sourceMappingURL=deepMerge.d.ts.map

package/dist/utils/deepMerge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deepMerge.d.ts","sourceRoot":"","sources":["../../src/utils/deepMerge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzD,MAAM,EAAE,CAAC,EACT,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,GACjB,CAAC,CA+BH;AAeD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5D,GAAG,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAChC,CAAC,CAKH"}

package/dist/utils/deepMerge.js

@@ -0,0 +1,59 @@
+/**
+ * Deep merge utility for configuration objects
+ *
+ * Recursively merges two objects with the following behavior:
+ * - Nested objects are merged recursively
+ * - Arrays are concatenated (not replaced)
+ * - Primitives from source override target
+ * - Null and undefined values are preserved
+ *
+ * @example
+ * ```ts
+ * const base = { plugins: ['A'], options: { debug: true } };
+ * const override = { plugins: ['B'], options: { verbose: true } };
+ * deepMerge(base, override);
+ * // Result: { plugins: ['A', 'B'], options: { debug: true, verbose: true } }
+ * ```
+ */
+export function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key in source) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            continue;
+        }
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
+            result[key] = [...targetValue, ...sourceValue];
+            continue;
+        }
+        if (isPlainObject(sourceValue) &&
+            isPlainObject(targetValue)) {
+            result[key] = deepMerge(targetValue, sourceValue);
+            continue;
+        }
+        result[key] = sourceValue;
+    }
+    return result;
+}
+/**
+ * Checks if a value is a plain object (not Array, Date, null, etc.)
+ */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Merge multiple configuration objects from left to right
+ *
+ * @example
+ * ```ts
+ * const merged = mergeConfigs(base, mode, module, override);
+ * ```
+ */
+export function mergeConfigs(...configs) {
+    return configs.reduce((acc, config) => deepMerge(acc, config), {});
+}