@quvel-kit/core 1.1.0

package/dist/config/moduleTransformer.js

@@ -0,0 +1,76 @@
+/**
+ * Get merged build configuration from all modules
+ */
+function getBuildConfig(modules, _ctx) {
+    const merged = {
+        boot: [],
+        css: [],
+        animations: [],
+        plugins: [],
+    };
+    for (const module of modules) {
+        if (!module.build) {
+            continue;
+        }
+        const buildConfig = module.build;
+        if (buildConfig.boot) {
+            merged.boot = merged.boot || [];
+            merged.boot.push(...buildConfig.boot);
+        }
+        if (buildConfig.css) {
+            merged.css = merged.css || [];
+            merged.css.push(...buildConfig.css);
+        }
+        if (buildConfig.animations) {
+            merged.animations = merged.animations || [];
+            merged.animations.push(...buildConfig.animations);
+        }
+        if (buildConfig.plugins) {
+            merged.plugins = merged.plugins || [];
+            merged.plugins.push(...buildConfig.plugins);
+        }
+    }
+    return merged;
+}
+/**
+ * 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 function createModuleTransformer(modules) {
+    return (config, ctx) => {
+        const moduleBuildConfig = getBuildConfig(modules, ctx);
+        const cfg = config;
+        if (moduleBuildConfig.boot && moduleBuildConfig.boot.length > 0) {
+            cfg.boot = cfg.boot || [];
+            cfg.boot.push(...moduleBuildConfig.boot);
+        }
+        if (moduleBuildConfig.css && moduleBuildConfig.css.length > 0) {
+            cfg.css = cfg.css || [];
+            cfg.css.push(...moduleBuildConfig.css);
+        }
+        if (moduleBuildConfig.animations && moduleBuildConfig.animations.length > 0) {
+            if (Array.isArray(cfg.animations)) {
+                cfg.animations.push(...moduleBuildConfig.animations);
+            }
+            else {
+                cfg.animations = moduleBuildConfig.animations;
+            }
+        }
+        if (moduleBuildConfig.plugins && moduleBuildConfig.plugins.length > 0) {
+            cfg.framework = cfg.framework || {};
+            cfg.framework.plugins = cfg.framework.plugins || [];
+            cfg.framework.plugins.push(...moduleBuildConfig.plugins);
+        }
+        return config;
+    };
+}

package/dist/config/quvel.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Quvel Configuration
+ *
+ * Single entry point for configuring the Quvel framework
+ */
+import type { QuvelConfig, QuvelConfigInput } from './quvel.types.js';
+import { DEFAULT_LOCALE_MAPPING } from '../services/ValidationService.js';
+/**
+ * Re-export types for convenience
+ */
+export type { LocaleMapping, QuvelConfig, QuvelConfigInput } from './quvel.types.js';
+/**
+ * Re-export DEFAULT_LOCALE_MAPPING for convenience
+ */
+export { DEFAULT_LOCALE_MAPPING };
+/**
+ * Define Quvel configuration
+ * Single entry point for configuring the framework
+ *
+ * Automatically:
+ * - Includes core module
+ * - Gathers translations from all modules
+ * - Sets up i18n and validation services
+ *
+ * @param config - Quvel configuration input
+ * @returns Resolved Quvel configuration
+ *
+ * @example
+ * ```typescript
+ * import { defineQuvelConfig } from '@quvel-kit/core';
+ * import { AuthModule } from './modules/Auth';
+ *
+ * export const config = defineQuvelConfig({
+ *   modules: [AuthModule],
+ *   localeMapping: { 'en-US': 'en', 'es-MX': 'es' }, // optional
+ * });
+ * ```
+ */
+export declare function defineQuvelConfig(config: QuvelConfigInput): QuvelConfig;
+//# sourceMappingURL=quvel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quvel.d.ts","sourceRoot":"","sources":["../../src/config/quvel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAItE,OAAO,EAAqB,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAI7F;;GAEG;AACH,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAErF;;GAEG;AACH,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,CAmCvE"}

package/dist/config/quvel.js

@@ -0,0 +1,59 @@
+/**
+ * Quvel Configuration
+ *
+ * Single entry point for configuring the Quvel framework
+ */
+import { defineQuvelModule } from '../module.js';
+import { I18nService } from '../services/I18nService.js';
+import { ValidationService, DEFAULT_LOCALE_MAPPING } from '../services/ValidationService.js';
+import { getTranslations } from '../modules/index.js';
+import { getSupportedLocales } from './i18n.js';
+/**
+ * Re-export DEFAULT_LOCALE_MAPPING for convenience
+ */
+export { DEFAULT_LOCALE_MAPPING };
+/**
+ * Define Quvel configuration
+ * Single entry point for configuring the framework
+ *
+ * Automatically:
+ * - Includes core module
+ * - Gathers translations from all modules
+ * - Sets up i18n and validation services
+ *
+ * @param config - Quvel configuration input
+ * @returns Resolved Quvel configuration
+ *
+ * @example
+ * ```typescript
+ * import { defineQuvelConfig } from '@quvel-kit/core';
+ * import { AuthModule } from './modules/Auth';
+ *
+ * export const config = defineQuvelConfig({
+ *   modules: [AuthModule],
+ *   localeMapping: { 'en-US': 'en', 'es-MX': 'es' }, // optional
+ * });
+ * ```
+ */
+export function defineQuvelConfig(config) {
+    const { modules = [], localeMapping, core = true, } = config;
+    const allModules = [];
+    if (core) {
+        const coreOptions = typeof core === 'object' ? core : {};
+        allModules.push(defineQuvelModule(coreOptions));
+    }
+    allModules.push(...modules);
+    const supportedLocales = getSupportedLocales();
+    const messages = {};
+    for (const locale of supportedLocales) {
+        messages[locale] = getTranslations(allModules, locale);
+    }
+    I18nService.setTranslations(messages);
+    const resolvedLocaleMapping = localeMapping || DEFAULT_LOCALE_MAPPING;
+    ValidationService.setLocaleMapping(resolvedLocaleMapping);
+    return {
+        modules: allModules,
+        messages,
+        localeMapping: resolvedLocaleMapping,
+    };
+}

package/dist/config/quvel.types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Quvel Configuration Types
+ *
+ * Type definitions for the Quvel configuration system
+ */
+import type { Module } from '../modules/types.js';
+/**
+ * Locale mapping configuration for validation
+ * Maps i18n locale codes to Zod locale codes
+ */
+export interface LocaleMapping {
+    [localeCode: string]: string;
+}
+/**
+ * User-provided Quvel configuration
+ * This is what users pass to defineQuvelConfig()
+ */
+export interface QuvelConfigInput {
+    /**
+     * Application modules
+     * Core module is automatically included unless core: false
+     */
+    modules?: Module[];
+    /**
+     * Locale mapping for validation (Zod locales)
+     * Optional - uses DEFAULT_LOCALE_MAPPING if not provided
+     */
+    localeMapping?: LocaleMapping;
+    /**
+     * Core module options
+     * Set to false to disable core module entirely
+     */
+    core?: boolean | {
+        /**
+         * Whether to include core i18n translations
+         * @default true
+         */
+        includeI18n?: boolean;
+    };
+}
+/**
+ * Resolved Quvel configuration
+ * This is what defineQuvelConfig() returns after processing
+ */
+export interface QuvelConfig {
+    /**
+     * All modules (use with getServices, getRoutes, getTranslations helpers)
+     */
+    modules: Module[];
+    /**
+     * Aggregated i18n messages from all modules
+     */
+    messages: Record<string, Record<string, unknown>>;
+    /**
+     * Locale mapping for validation
+     */
+    localeMapping: LocaleMapping;
+}
+//# sourceMappingURL=quvel.types.d.ts.map

package/dist/config/quvel.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quvel.types.d.ts","sourceRoot":"","sources":["../../src/config/quvel.types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;OAGG;IACH,aAAa,CAAC,EAAE,aAAa,CAAC;IAE9B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG;QACf;;;WAGG;QACH,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAElD;;OAEG;IACH,aAAa,EAAE,aAAa,CAAC;CAC9B"}

package/dist/config/quvel.types.js

@@ -0,0 +1,6 @@
+/**
+ * Quvel Configuration Types
+ *
+ * Type definitions for the Quvel configuration system
+ */
+export {};

package/dist/container/ServiceContainer.d.ts

@@ -0,0 +1,107 @@
+import type { Service, ServiceClass } from './types.js';
+import type { QSsrContext } from '@quasar/app-vite';
+import type { AppConfig } from '../types/app.types.js';
+import { LogService } from "../services/LogService.js";
+import { ApiService } from "../services/ApiService.js";
+import { I18nService } from "../services/I18nService.js";
+import { ValidationService } from "../services/ValidationService.js";
+import { WebSocketService } from "../services/WebSocketService.js";
+import { ThemeService } from "../services/ThemeService.js";
+/**
+ * Service Container
+ *
+ * Manages service lifecycle with three phases:
+ * 1. Initialize - Instantiate all service classes with config
+ * 2. Register - Call register() for dependency injection (container access)
+ * 3. Boot - Call boot() on SSR-aware services (with req/res context)
+ */
+export declare class ServiceContainer {
+    private readonly _ssrContext?;
+    private readonly services;
+    private readonly serviceClassToKey;
+    private readonly _config;
+    constructor(_ssrContext?: (QSsrContext | null) | undefined, serviceClasses?: Map<string, ServiceClass>);
+    /**
+     * Get the application config
+     */
+    get config(): AppConfig;
+    /**
+     * Get the SSR context
+     */
+    get ssrContext(): QSsrContext | null | undefined;
+    /**
+     * Initialize services from their classes with config and SSR context
+     */
+    private initializeServices;
+    /**
+     * Boot SSR-aware services with the SSR context
+     */
+    private bootServices;
+    /**
+     * Registers all core and dynamic services
+     */
+    private registerServices;
+    /**
+     * Retrieves a service by its class
+     */
+    get<T extends Service>(ServiceClass: ServiceClass<T>): T;
+    /**
+     * Get a service by name
+     */
+    getByName<T extends Service>(name: string): T | undefined;
+    /**
+     * Adds a new service by class
+     */
+    addService<T extends Service>(ServiceClass: ServiceClass<T>, overwrite?: boolean): boolean;
+    /**
+     * Checks if a service exists by class
+     */
+    hasService<T extends Service>(ServiceClass: ServiceClass<T>): boolean;
+    /**
+     * Removes a service and shuts it down if possible
+     */
+    removeService(name: string): boolean;
+    /**
+     * Helper to handle service lifecycle method errors
+     */
+    private handleServiceError;
+    /**
+     * Boot a single service with error handling
+     */
+    private bootService;
+    /**
+     * Register a single service with error handling
+     */
+    private registerService;
+    /**
+     * Type guard to check if a service has a boot method (SSR-aware)
+     */
+    private hasBoot;
+    /**
+     * Checks if a service implements the ` shutdown ` method
+     */
+    private isShutdownable;
+    /**
+     * Type guard to check if a service implements `RegisterService`
+     */
+    private isRegisterable;
+    /**
+     * Convenience getters for core services
+     */
+    get log(): LogService;
+    get api(): ApiService;
+    get i18n(): I18nService;
+    get validation(): ValidationService;
+    get task(): <Result = unknown, Payload = unknown>(options: import("../index.js").TaskOptions<Result, Payload>, mutableProps?: (keyof import("../index.js").TaskOptions<Result, Payload>)[]) => {
+        isActive: import("vue").ComputedRef<boolean>;
+        run: (customOptions?: Partial<import("../index.js").TaskOptions<Result, Payload>>) => Promise<Result | false>;
+        reset: () => void;
+        state: import("vue").Ref<import("../index.js").TaskState>;
+        error: import("vue").Ref<unknown>;
+        errors: import("vue").Ref<import("../index.js").ErrorBag>;
+        result: import("vue").Ref<Result | undefined>;
+    };
+    get ws(): WebSocketService;
+    get theme(): ThemeService;
+}
+//# sourceMappingURL=ServiceContainer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ServiceContainer.d.ts","sourceRoot":"","sources":["../../src/container/ServiceContainer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,OAAO,EACP,YAAY,EAGb,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAC,UAAU,EAAC,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAC,UAAU,EAAC,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAC,WAAW,EAAC,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAC,iBAAiB,EAAC,MAAM,kCAAkC,CAAC;AAEnE,OAAO,EAAC,gBAAgB,EAAC,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AAGzD;;;;;;;GAOG;AACH,qBAAa,gBAAgB;IAMzB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;IAL/B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2C;IACpE,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwC;IAC1E,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAY;gBAGjB,WAAW,CAAC,GAAE,WAAW,GAAG,IAAI,aAAA,EACjD,cAAc,GAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAa;IAQvD;;OAEG;IACH,IAAI,MAAM,IAAI,SAAS,CAEtB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,WAAW,GAAG,IAAI,GAAG,SAAS,CAE/C;IAED;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAS1B;;OAEG;IACH,OAAO,CAAC,YAAY;IAMpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC;IAoBxD;;OAEG;IACH,SAAS,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAIzD;;OAEG;IACH,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,SAAS,UAAQ,GAAG,OAAO;IAgBxF;;OAEG;IACH,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,OAAO;IAIrE;;OAEG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUpC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;OAEG;IACH,OAAO,CAAC,WAAW;IAUnB;;OAEG;IACH,OAAO,CAAC,eAAe;IAUvB;;OAEG;IACH,OAAO,CAAC,OAAO;IASf;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IACH,OAAO,CAAC,cAAc;IAItB;;OAEG;IAEH,IAAI,GAAG,IAAI,UAAU,CAEpB;IAED,IAAI,GAAG,IAAI,UAAU,CAEpB;IAED,IAAI,IAAI,IAAI,WAAW,CAEtB;IAED,IAAI,UAAU,IAAI,iBAAiB,CAElC;IAED,IAAI,IAAI;;2BA1LP,CAAF;;;;;;MA8LE;IAED,IAAI,EAAE,IAAI,gBAAgB,CAEzB;IAED,IAAI,KAAK,IAAI,YAAY,CAExB;CACF"}

package/dist/container/ServiceContainer.js

@@ -0,0 +1,201 @@
+import { LogService } from "../services/LogService.js";
+import { ApiService } from "../services/ApiService.js";
+import { I18nService } from "../services/I18nService.js";
+import { ValidationService } from "../services/ValidationService.js";
+import { TaskService } from "../services/TaskService.js";
+import { WebSocketService } from "../services/WebSocketService.js";
+import { ThemeService } from "../services/ThemeService.js";
+import { createConfig } from '../utils/config.js';
+/**
+ * Service Container
+ *
+ * Manages service lifecycle with three phases:
+ * 1. Initialize - Instantiate all service classes with config
+ * 2. Register - Call register() for dependency injection (container access)
+ * 3. Boot - Call boot() on SSR-aware services (with req/res context)
+ */
+export class ServiceContainer {
+    _ssrContext;
+    services = new Map();
+    serviceClassToKey = new Map();
+    _config;
+    constructor(_ssrContext, serviceClasses = new Map()) {
+        this._ssrContext = _ssrContext;
+        this._config = createConfig(this._ssrContext);
+        this.initializeServices(serviceClasses);
+        this.registerServices();
+        this.bootServices();
+    }
+    /**
+     * Get the application config
+     */
+    get config() {
+        return this._config;
+    }
+    /**
+     * Get the SSR context
+     */
+    get ssrContext() {
+        return this._ssrContext;
+    }
+    /**
+     * Initialize services from their classes with config and SSR context
+     */
+    initializeServices(serviceClasses) {
+        for (const [name, ServiceClass] of serviceClasses) {
+            const instance = new ServiceClass(this._config, this._ssrContext);
+            this.services.set(name, instance);
+            this.serviceClassToKey.set(ServiceClass, name);
+        }
+    }
+    /**
+     * Boot SSR-aware services with the SSR context
+     */
+    bootServices() {
+        for (const [name, service] of this.services) {
+            this.bootService(name, service);
+        }
+    }
+    /**
+     * Registers all core and dynamic services
+     */
+    registerServices() {
+        for (const [name, service] of this.services) {
+            this.registerService(name, service);
+        }
+    }
+    /**
+     * Retrieves a service by its class
+     */
+    get(ServiceClass) {
+        const key = this.serviceClassToKey.get(ServiceClass);
+        if (key && this.services.has(key)) {
+            return this.services.get(key);
+        }
+        const name = ServiceClass.name;
+        if (this.services.has(name)) {
+            return this.services.get(name);
+        }
+        const instance = new ServiceClass(this._config, this._ssrContext);
+        this.services.set(name, instance);
+        this.registerService(name, instance);
+        this.bootService(name, instance);
+        return instance;
+    }
+    /**
+     * Get a service by name
+     */
+    getByName(name) {
+        return this.services.get(name);
+    }
+    /**
+     * Adds a new service by class
+     */
+    addService(ServiceClass, overwrite = false) {
+        const name = ServiceClass.name;
+        if (this.services.has(name) && !overwrite) {
+            return false;
+        }
+        const instance = new ServiceClass(this._config, this._ssrContext);
+        this.services.set(name, instance);
+        this.registerService(name, instance);
+        this.bootService(name, instance);
+        return true;
+    }
+    /**
+     * Checks if a service exists by class
+     */
+    hasService(ServiceClass) {
+        return this.services.has(ServiceClass.name);
+    }
+    /**
+     * Removes a service and shuts it down if possible
+     */
+    removeService(name) {
+        const service = this.services.get(name);
+        if (this.isShutdownable(service)) {
+            service.shutdown();
+        }
+        this.services.delete(name);
+        return true;
+    }
+    /**
+     * Helper to handle service lifecycle method errors
+     */
+    handleServiceError(operation, serviceName, error) {
+        console.error(`Failed to ${operation} service ${serviceName}:`, error);
+        throw new Error(`Service ${operation} failed for ${serviceName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    /**
+     * Boot a single service with error handling
+     */
+    bootService(name, service) {
+        if (this.hasBoot(service)) {
+            try {
+                service.boot();
+            }
+            catch (error) {
+                this.handleServiceError('boot', name, error);
+            }
+        }
+    }
+    /**
+     * Register a single service with error handling
+     */
+    registerService(name, service) {
+        if (this.isRegisterable(service)) {
+            try {
+                service.register(this);
+            }
+            catch (error) {
+                this.handleServiceError('register', name, error);
+            }
+        }
+    }
+    /**
+     * Type guard to check if a service has a boot method (SSR-aware)
+     */
+    hasBoot(service) {
+        return (typeof service === 'object' &&
+            service !== null &&
+            'boot' in service &&
+            typeof service.boot === 'function');
+    }
+    /**
+     * Checks if a service implements the ` shutdown ` method
+     */
+    isShutdownable(service) {
+        return typeof service === 'object' && service !== null && 'shutdown' in service;
+    }
+    /**
+     * Type guard to check if a service implements `RegisterService`
+     */
+    isRegisterable(service) {
+        return typeof service === 'object' && service !== null && 'register' in service;
+    }
+    /**
+     * Convenience getters for core services
+     */
+    get log() {
+        return this.get(LogService);
+    }
+    get api() {
+        return this.get(ApiService);
+    }
+    get i18n() {
+        return this.get(I18nService);
+    }
+    get validation() {
+        return this.get(ValidationService);
+    }
+    get task() {
+        const taskService = this.get(TaskService);
+        return taskService.task.bind(taskService);
+    }
+    get ws() {
+        return this.get(WebSocketService);
+    }
+    get theme() {
+        return this.get(ThemeService);
+    }
+}

package/dist/container/types/vue.d.ts

@@ -0,0 +1,9 @@
+import type { ServiceContainer } from '../ServiceContainer';
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $quvel: ServiceContainer;
+  }
+}
+
+export {};

package/dist/container/types.d.ts

@@ -0,0 +1,81 @@
+import type { QSsrContext } from '@quasar/app-vite';
+import type { ServiceContainer } from './ServiceContainer';
+import type { AppConfig } from '../types/app.types.js';
+/**
+ * Base service type
+ */
+export type Service = object;
+/**
+ * Interface for services that need post-initialization setup.
+ *
+ * Called after all services have completed their register() phase. This is where
+ * services can safely use their dependencies for initialization logic.
+ *
+ * ✅ Safe to call methods on dependencies in boot() - all services are registered.
+ *
+ * @example
+ * ```typescript
+ * boot(): void {
+ *   // ✅ All dependencies are ready - safe to use
+ *   const locale = this.config.locale;
+ *   this.api.setHeader('Accept-Language', locale);
+ *
+ *   if (this.ssrContext?.$q) {
+ *     this.$q.dark.set(this.theme.isDark);
+ *   }
+ * }
+ * ```
+ */
+export interface SsrAwareService extends Service {
+    boot(): void;
+}
+/**
+ * Interface for services that need to register with the container.
+ *
+ * Called after all services are instantiated but before any boot() methods.
+ *
+ * ⚠️ CRITICAL: The register() method is ONLY for storing references to dependencies.
+ * Do NOT call methods on dependencies during register() as they may not be fully
+ * initialized yet. Use boot() for initialization logic that requires dependencies.
+ *
+ * @example
+ * ```typescript
+ * // ✅ CORRECT: Store references only (destructuring recommended)
+ * register({ api, config, ssrContext }: ServiceContainer): void {
+ *   this.api = api;
+ *   this.config = config;
+ *   // ssrContext available from container, no need to store it
+ *   this.client = createClient(ssrContext, config);
+ * }
+ *
+ * // ✅ ALSO CORRECT: Access via parameter
+ * register(quvel: ServiceContainer): void {
+ *   this.api = quvel.api;
+ *   this.config = quvel.config;
+ * }
+ *
+ * // ❌ WRONG: Don't call methods - race condition!
+ * register({ api }: ServiceContainer): void {
+ *   const data = api.get('/data'); // May fail!
+ * }
+ * ```
+ */
+export interface RegisterService {
+    register(quvel: ServiceContainer): void;
+}
+/**
+ * Interface for services that can be shut down
+ */
+export interface ShutdownService {
+    shutdown(): void;
+}
+/**
+ * Service class constructor type
+ * Services receive config and ssrContext in their constructor
+ */
+export type ServiceClass<T extends Service = Service> = new (config: AppConfig, ssrContext?: QSsrContext | null) => T;
+/**
+ * Service instance type (may implement optional lifecycle hooks)
+ */
+export type ServiceInstance = Service & Partial<RegisterService> & Partial<SsrAwareService>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/container/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,eAAgB,SAAQ,OAAO;IAC9C,IAAI,IAAI,IAAI,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,IAAI,IAAI,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,IAAI,KACtD,MAAM,EAAE,SAAS,EACjB,UAAU,CAAC,EAAE,WAAW,GAAG,IAAI,KAC5B,CAAC,CAAC;AAEP;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,CAAC,eAAe,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC"}

package/dist/container/types.js

@@ -0,0 +1 @@
+export {};

package/dist/i18n/en-US/common.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    task: {
+        success: string;
+        error: string;
+    };
+    errors: {
+        notFound: {
+            title: string;
+            description: string;
+            help: string;
+            actions: {
+                home: string;
+                back: string;
+            };
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=common.d.ts.map

package/dist/i18n/en-US/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/i18n/en-US/common.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,wBAgBE"}