@qiu_qiu/vue-auto-component-framework 1.0.0

package/README.md

@@ -0,0 +1,72 @@
+# Vue Auto Component Framework
+
+A Vue3 TypeScript framework that provides automatic component registration and layout system functionality.
+
+## Features
+
+- 🚀 Automatic component registration from `@/components` directory
+- 🎨 Built-in layout system with responsive design
+- 📦 TypeScript support with full type definitions
+- 🔧 Compatible with Vue 3 Composition API
+- 🛠️ Error handling and recovery mechanisms
+
+## Installation
+
+```bash
+npm install vue-auto-component-framework
+```
+
+## Usage
+
+```typescript
+import { createApp } from 'vue-auto-component-framework'
+import App from './App.vue'
+
+const app = await createApp(App, {
+  componentsPath: '@/components', // optional, defaults to '@/components'
+  layoutConfig: {
+    header: true,
+    sidebar: true,
+    footer: true,
+    responsive: true
+  }
+})
+
+app.mount('#app')
+```
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Type checking
+npm run type-check
+
+# Linting
+npm run lint
+```
+
+## Project Structure
+
+```
+src/
+├── core/           # Core framework classes
+├── layout/         # Layout components
+├── types/          # TypeScript type definitions
+└── index.ts        # Main entry point
+```
+
+## License
+
+MIT

package/dist/core/AppCreator.d.ts

@@ -0,0 +1,33 @@
+import { type App, type Component } from 'vue';
+import type { FrameworkOptions, LayoutConfig } from '@/types';
+import { LayoutManager } from '@/layout/LayoutManager';
+/**
+ * App creator implementation
+ * Handles Vue app creation with framework features
+ */
+export declare class AppCreator {
+    private componentScanner;
+    private layoutManager;
+    constructor();
+    /**
+     * Create Vue app with framework features and error recovery
+     */
+    createApp(rootComponent?: Component, options?: FrameworkOptions): Promise<App>;
+    /**
+     * Get current layout configuration
+     */
+    getLayoutConfig(): Required<LayoutConfig>;
+    /**
+     * Update layout configuration
+     */
+    updateLayoutConfig(config: LayoutConfig): void;
+    /**
+     * Register a custom layout component
+     */
+    registerLayout(name: string, component: Component): void;
+    /**
+     * Get layout manager instance
+     */
+    getLayoutManager(): LayoutManager;
+}
+//# sourceMappingURL=AppCreator.d.ts.map

package/dist/core/AppCreator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppCreator.d.ts","sourceRoot":"","sources":["../../src/core/AppCreator.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,GAAG,EAAE,KAAK,SAAS,EAAE,MAAM,KAAK,CAAA;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAG7D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAEtD;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,aAAa,CAAe;;IAOpC;;OAEG;IACG,SAAS,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,gBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC;IAmFxF;;OAEG;IACH,eAAe,IAAI,QAAQ,CAAC,YAAY,CAAC;IAIzC;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAI9C;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAIxD;;OAEG;IACH,gBAAgB,IAAI,aAAa;CAGlC"}

package/dist/core/AppCreator.js

@@ -0,0 +1,100 @@
+import { createApp as vueCreateApp } from 'vue';
+import { ComponentScanner } from './ComponentScanner';
+import { ErrorHandler } from './ErrorHandler';
+import { LayoutManager } from '@/layout/LayoutManager';
+/**
+ * App creator implementation
+ * Handles Vue app creation with framework features
+ */
+export class AppCreator {
+    constructor() {
+        this.componentScanner = new ComponentScanner();
+        this.layoutManager = new LayoutManager();
+    }
+    /**
+     * Create Vue app with framework features and error recovery
+     */
+    async createApp(rootComponent, options = {}) {
+        try {
+            const app = vueCreateApp(rootComponent || {});
+            // Initialize layout system with custom configuration
+            if (options.layoutConfig) {
+                this.layoutManager.updateConfig(options.layoutConfig);
+            }
+            try {
+                this.layoutManager.initializeLayouts(app);
+            }
+            catch (error) {
+                const layoutError = ErrorHandler.createLayoutError('Failed to initialize layout system', { layoutConfig: options.layoutConfig }, error);
+                ErrorHandler.logError(layoutError);
+                // Continue without layout system - app can still function
+            }
+            // Install additional plugins with error handling
+            if (options.plugins) {
+                options.plugins.forEach((plugin, index) => {
+                    try {
+                        app.use(plugin);
+                    }
+                    catch (error) {
+                        const pluginError = ErrorHandler.createAppError(`Failed to install plugin at index ${index}`, { pluginIndex: index }, error);
+                        ErrorHandler.logError(pluginError);
+                        // Continue with other plugins - partial functionality is better than none
+                    }
+                });
+            }
+            // Scan and register components with comprehensive error handling
+            const componentsPath = options.componentsPath || '@/components';
+            try {
+                const components = await this.componentScanner.scanComponents(componentsPath);
+                this.componentScanner.registerComponents(app, components);
+                // Report any errors that occurred during scanning/registration
+                const scanErrors = this.componentScanner.getErrors();
+                if (scanErrors.length > 0) {
+                    console.warn(`Component scanning completed with ${scanErrors.length} errors`);
+                    // Log summary of errors for debugging
+                    const errorSummary = ErrorHandler.formatErrorSummary(scanErrors);
+                    console.warn(errorSummary);
+                }
+            }
+            catch (error) {
+                // Critical component scanning error - log but don't fail app creation
+                const criticalError = ErrorHandler.createAppError('Critical error during component scanning - app will continue without auto-registered components', { componentsPath }, error);
+                ErrorHandler.logError(criticalError);
+                // App can still function without auto-registered components
+                console.warn('Application created successfully but component auto-registration failed');
+            }
+            return app;
+        }
+        catch (error) {
+            // Critical app creation error
+            const appError = ErrorHandler.createAppError('Failed to create Vue application', { rootComponent: rootComponent?.name || 'anonymous', options }, error);
+            ErrorHandler.logError(appError);
+            // Re-throw critical errors as they prevent app from functioning
+            throw appError;
+        }
+    }
+    /**
+     * Get current layout configuration
+     */
+    getLayoutConfig() {
+        return this.layoutManager.getConfig();
+    }
+    /**
+     * Update layout configuration
+     */
+    updateLayoutConfig(config) {
+        this.layoutManager.updateConfig(config);
+    }
+    /**
+     * Register a custom layout component
+     */
+    registerLayout(name, component) {
+        this.layoutManager.registerLayout(name, component);
+    }
+    /**
+     * Get layout manager instance
+     */
+    getLayoutManager() {
+        return this.layoutManager;
+    }
+}

package/dist/core/ComponentRegistry.d.ts

@@ -0,0 +1,44 @@
+import type { Component } from 'vue';
+import type { ComponentRegistry as IComponentRegistry } from '@/types';
+/**
+ * Component registry implementation
+ * Manages registration and retrieval of Vue components with conflict detection
+ */
+export declare class ComponentRegistry implements IComponentRegistry {
+    private components;
+    private componentPaths;
+    /**
+     * Register a component with the given name
+     * Handles name conflicts by generating unique names using file paths
+     */
+    register(name: string, component: Component, filePath?: string): void;
+    /**
+     * Get a component by name
+     */
+    get(name: string): Component | undefined;
+    /**
+     * Get all registered components
+     */
+    getAll(): Map<string, Component>;
+    /**
+     * Check if a component is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get the file path for a registered component
+     */
+    getPath(name: string): string | undefined;
+    /**
+     * Get all component names
+     */
+    getNames(): string[];
+    /**
+     * Clear all registered components
+     */
+    clear(): void;
+    /**
+     * Resolve name conflicts by using file path information
+     */
+    private resolveNameConflict;
+}
+//# sourceMappingURL=ComponentRegistry.d.ts.map

package/dist/core/ComponentRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentRegistry.d.ts","sourceRoot":"","sources":["../../src/core/ComponentRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AACpC,OAAO,KAAK,EAAE,iBAAiB,IAAI,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAGtE;;;GAGG;AACH,qBAAa,iBAAkB,YAAW,kBAAkB;IAC1D,OAAO,CAAC,UAAU,CAAoC;IACtD,OAAO,CAAC,cAAc,CAAiC;IAEvD;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI;IAoDrE;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAIxC;;OAEG;IACH,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;IAIhC;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIzC;;OAEG;IACH,QAAQ,IAAI,MAAM,EAAE;IAIpB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,OAAO,CAAC,mBAAmB;CA2B5B"}

package/dist/core/ComponentRegistry.js

@@ -0,0 +1,110 @@
+import { ErrorHandler } from './ErrorHandler';
+/**
+ * Component registry implementation
+ * Manages registration and retrieval of Vue components with conflict detection
+ */
+export class ComponentRegistry {
+    constructor() {
+        this.components = new Map();
+        this.componentPaths = new Map();
+    }
+    /**
+     * Register a component with the given name
+     * Handles name conflicts by generating unique names using file paths
+     */
+    register(name, component, filePath) {
+        if (!name || typeof name !== 'string') {
+            throw ErrorHandler.createRegistrationError('Component name must be a non-empty string', name, filePath);
+        }
+        if (!component) {
+            throw ErrorHandler.createRegistrationError('Component cannot be null or undefined', name, filePath);
+        }
+        let finalName = name;
+        // Handle name conflicts by generating unique names
+        if (this.components.has(name)) {
+            const existingPath = this.componentPaths.get(name);
+            // Log the conflict for debugging
+            const conflictError = ErrorHandler.createNameConflictError(name, existingPath || 'unknown', filePath || 'unknown');
+            ErrorHandler.logError(conflictError);
+            // Resolve conflict by generating unique name
+            if (filePath) {
+                finalName = this.resolveNameConflict(name, filePath);
+            }
+            else {
+                // If no file path provided, append a counter
+                let counter = 1;
+                while (this.components.has(`${name}_${counter}`)) {
+                    counter++;
+                }
+                finalName = `${name}_${counter}`;
+            }
+            console.info(`Resolved name conflict: ${name} -> ${finalName}`);
+        }
+        this.components.set(finalName, component);
+        if (filePath) {
+            this.componentPaths.set(finalName, filePath);
+        }
+    }
+    /**
+     * Get a component by name
+     */
+    get(name) {
+        return this.components.get(name);
+    }
+    /**
+     * Get all registered components
+     */
+    getAll() {
+        return new Map(this.components);
+    }
+    /**
+     * Check if a component is registered
+     */
+    has(name) {
+        return this.components.has(name);
+    }
+    /**
+     * Get the file path for a registered component
+     */
+    getPath(name) {
+        return this.componentPaths.get(name);
+    }
+    /**
+     * Get all component names
+     */
+    getNames() {
+        return Array.from(this.components.keys());
+    }
+    /**
+     * Clear all registered components
+     */
+    clear() {
+        this.components.clear();
+        this.componentPaths.clear();
+    }
+    /**
+     * Resolve name conflicts by using file path information
+     */
+    resolveNameConflict(baseName, filePath) {
+        // Extract directory structure to create unique suffix
+        const pathParts = filePath.split(/[/\\]/).filter(part => part && part !== '.' && part !== '..');
+        // Remove file extension and base name from path parts
+        const fileName = pathParts[pathParts.length - 1]?.replace(/\.(vue|ts|js)$/, '');
+        const dirParts = pathParts.slice(0, -1);
+        // Create suffix from directory structure
+        let suffix = '';
+        if (dirParts.length > 0) {
+            suffix = dirParts.join('_');
+        }
+        // Generate unique name
+        let uniqueName = suffix ? `${baseName}_${suffix}` : baseName;
+        // If still conflicts, add counter
+        let counter = 1;
+        const originalUniqueName = uniqueName;
+        while (this.components.has(uniqueName)) {
+            uniqueName = `${originalUniqueName}_${counter}`;
+            counter++;
+        }
+        return uniqueName;
+    }
+}

package/dist/core/ComponentScanner.d.ts

@@ -0,0 +1,50 @@
+import type { App } from 'vue';
+import type { ComponentScanner as IComponentScanner, ComponentInfo, FrameworkError } from '@/types';
+import { ComponentRegistry } from './ComponentRegistry';
+/**
+ * Component scanner implementation
+ * Handles scanning and registering Vue components with error recovery
+ */
+export declare class ComponentScanner implements IComponentScanner {
+    private _fileScanner;
+    private _registry;
+    private _errors;
+    constructor();
+    /**
+     * Get all errors encountered during scanning and registration
+     */
+    getErrors(): FrameworkError[];
+    /**
+     * Clear accumulated errors
+     */
+    clearErrors(): void;
+    /**
+     * Scan components in the specified base path with error recovery
+     */
+    scanComponents(basePath: string): Promise<ComponentInfo[]>;
+    /**
+     * Register components in the Vue app with conflict detection and error recovery
+     */
+    registerComponents(app: App, components: ComponentInfo[]): void;
+    /**
+     * Get the internal component registry
+     */
+    getRegistry(): ComponentRegistry;
+    /**
+     * Generate component name from file path
+     */
+    private _generateComponentName;
+    /**
+     * Convert string to PascalCase
+     */
+    private _toPascalCase;
+    /**
+     * Dynamically load a Vue component from file path with enhanced error handling
+     */
+    private _loadComponent;
+    /**
+     * Validate if an object is a valid Vue component
+     */
+    private _isValidVueComponent;
+}
+//# sourceMappingURL=ComponentScanner.d.ts.map

package/dist/core/ComponentScanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComponentScanner.d.ts","sourceRoot":"","sources":["../../src/core/ComponentScanner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAC9B,OAAO,KAAK,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAEnG,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAGvD;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,OAAO,CAAuB;;IAOtC;;OAEG;IACH,SAAS,IAAI,cAAc,EAAE;IAI7B;;OAEG;IACH,WAAW,IAAI,IAAI;IAInB;;OAEG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAiEhE;;OAEG;IACH,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,IAAI;IA8D/D;;OAEG;IACH,WAAW,IAAI,iBAAiB;IAIhC;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAuB9B;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;YACW,cAAc;IAkC5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;CAqB7B"}

package/dist/core/ComponentScanner.js

@@ -0,0 +1,203 @@
+import { FileScanner } from './FileScanner';
+import { ComponentRegistry } from './ComponentRegistry';
+import { ErrorHandler } from './ErrorHandler';
+/**
+ * Component scanner implementation
+ * Handles scanning and registering Vue components with error recovery
+ */
+export class ComponentScanner {
+    constructor() {
+        this._errors = [];
+        this._fileScanner = new FileScanner();
+        this._registry = new ComponentRegistry();
+    }
+    /**
+     * Get all errors encountered during scanning and registration
+     */
+    getErrors() {
+        return [...this._errors];
+    }
+    /**
+     * Clear accumulated errors
+     */
+    clearErrors() {
+        this._errors = [];
+    }
+    /**
+     * Scan components in the specified base path with error recovery
+     */
+    async scanComponents(basePath) {
+        this.clearErrors();
+        try {
+            const scanResult = await this._fileScanner.scanDirectory(basePath, ['.vue']);
+            const components = [];
+            // Handle file scanning errors
+            if (scanResult.errors.length > 0) {
+                scanResult.errors.forEach(error => {
+                    const frameworkError = ErrorHandler.createScanError(`File scanning error: ${error.message}`, undefined, error);
+                    this._errors.push(frameworkError);
+                    ErrorHandler.logError(frameworkError);
+                });
+            }
+            // Process each found file with individual error handling
+            for (const filePath of scanResult.files) {
+                try {
+                    // Generate component name from file path
+                    const name = this._generateComponentName(filePath, basePath);
+                    // Dynamically import the Vue component
+                    const component = await this._loadComponent(filePath);
+                    components.push({
+                        name,
+                        component,
+                        path: filePath
+                    });
+                }
+                catch (error) {
+                    // Create detailed error but continue processing other components
+                    const frameworkError = ErrorHandler.createScanError(`Failed to process component file: ${filePath}`, filePath, error);
+                    this._errors.push(frameworkError);
+                    ErrorHandler.logError(frameworkError);
+                    // Continue with next component (error recovery)
+                    continue;
+                }
+            }
+            return components;
+        }
+        catch (error) {
+            // Critical scanning error - still try to return what we have
+            const frameworkError = ErrorHandler.createScanError(`Critical error during component scanning: ${error.message}`, basePath, error);
+            this._errors.push(frameworkError);
+            ErrorHandler.logError(frameworkError);
+            // Return empty array but don't throw - allow app to continue
+            return [];
+        }
+    }
+    /**
+     * Register components in the Vue app with conflict detection and error recovery
+     */
+    registerComponents(app, components) {
+        // Clear registry for fresh registration
+        this._registry.clear();
+        let successCount = 0;
+        let errorCount = 0;
+        components.forEach(({ name, component, path }) => {
+            try {
+                // Validate component before registration
+                if (!this._isValidVueComponent(component)) {
+                    const error = ErrorHandler.createInvalidComponentError(name, path, 'Component does not have required Vue component structure');
+                    this._errors.push(error);
+                    ErrorHandler.logError(error);
+                    errorCount++;
+                    return;
+                }
+                // Register in internal registry with conflict detection
+                this._registry.register(name, component, path);
+                // Get the final name (may be different due to conflict resolution)
+                const finalName = this._registry.getNames().find(registeredName => this._registry.get(registeredName) === component) || name;
+                // Register in Vue app
+                app.component(finalName, component);
+                successCount++;
+            }
+            catch (error) {
+                // Handle registration errors gracefully
+                const frameworkError = ErrorHandler.createRegistrationError(`Failed to register component: ${error.message}`, name, path, error);
+                this._errors.push(frameworkError);
+                ErrorHandler.logError(frameworkError);
+                errorCount++;
+                // Continue with next component (error recovery)
+            }
+        });
+        // Log summary of registration results
+        if (successCount > 0 || errorCount > 0) {
+            console.info(`Component registration completed: ${successCount} successful, ${errorCount} failed`);
+        }
+        // If we have errors but some components were registered successfully, 
+        // the app can still continue (graceful degradation)
+        if (errorCount > 0 && successCount === 0) {
+            console.warn('No components were successfully registered, but application will continue');
+        }
+    }
+    /**
+     * Get the internal component registry
+     */
+    getRegistry() {
+        return this._registry;
+    }
+    /**
+     * Generate component name from file path
+     */
+    _generateComponentName(filePath, basePath) {
+        // Remove base path to get relative path
+        let relativePath = filePath.replace(basePath, '').replace(/^[/\\]/, '');
+        // Remove file extension
+        relativePath = relativePath.replace(/\.(vue|ts|js)$/, '');
+        // Handle special characters and path separators
+        // Replace path separators and special characters with dashes
+        let normalizedName = relativePath
+            .replace(/[/\\]/g, '-') // Replace path separators
+            .replace(/[^a-zA-Z0-9-_]/g, '-') // Replace special characters
+            .replace(/-+/g, '-') // Replace multiple dashes with single dash
+            .replace(/^-|-$/g, ''); // Remove leading/trailing dashes
+        // Convert to PascalCase
+        return normalizedName
+            .split('-')
+            .filter(part => part.length > 0) // Remove empty parts
+            .map(part => this._toPascalCase(part))
+            .join('');
+    }
+    /**
+     * Convert string to PascalCase
+     */
+    _toPascalCase(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    }
+    /**
+     * Dynamically load a Vue component from file path with enhanced error handling
+     */
+    async _loadComponent(filePath) {
+        try {
+            // Dynamic import of the component module
+            const componentModule = await import(filePath);
+            // Handle different export patterns
+            let component = componentModule.default || componentModule;
+            // Validate that it's a valid Vue component
+            if (!component || (typeof component !== 'object' && typeof component !== 'function')) {
+                throw ErrorHandler.createInvalidComponentError(this._generateComponentName(filePath, ''), filePath, 'Invalid component export - must be object or function');
+            }
+            // For Vue SFC, ensure we have the component definition
+            if (component.__vccOpts) {
+                component = component.__vccOpts;
+            }
+            return component;
+        }
+        catch (error) {
+            // If it's already a FrameworkError, re-throw it
+            if (error instanceof Error && error.name === 'FrameworkError') {
+                throw error;
+            }
+            // Otherwise, wrap in import error
+            throw ErrorHandler.createImportError(filePath, error);
+        }
+    }
+    /**
+     * Validate if an object is a valid Vue component
+     */
+    _isValidVueComponent(component) {
+        if (!component)
+            return false;
+        // Check for function component
+        if (typeof component === 'function')
+            return true;
+        // Check for object component with render function or template
+        if (typeof component === 'object') {
+            return !!(component.render ||
+                component.template ||
+                component.setup ||
+                component.__vccOpts ||
+                component.components ||
+                component.data ||
+                component.methods);
+        }
+        return false;
+    }
+}

package/dist/core/ErrorHandler.d.ts

@@ -0,0 +1,51 @@
+import { FrameworkError } from '@/types';
+/**
+ * Error handler utility class for creating and managing framework errors
+ */
+export declare class ErrorHandler {
+    /**
+     * Create a component scan error
+     */
+    static createScanError(message: string, filePath?: string, cause?: Error): FrameworkError;
+    /**
+     * Create a component registration error
+     */
+    static createRegistrationError(message: string, componentName?: string, filePath?: string, cause?: Error): FrameworkError;
+    /**
+     * Create a layout initialization error
+     */
+    static createLayoutError(message: string, context?: Record<string, any>, cause?: Error): FrameworkError;
+    /**
+     * Create an app creation error
+     */
+    static createAppError(message: string, context?: Record<string, any>, cause?: Error): FrameworkError;
+    /**
+     * Create a file not found error
+     */
+    static createFileNotFoundError(filePath: string, cause?: Error): FrameworkError;
+    /**
+     * Create an invalid component error
+     */
+    static createInvalidComponentError(componentName: string, filePath: string, reason?: string, cause?: Error): FrameworkError;
+    /**
+     * Create a name conflict error
+     */
+    static createNameConflictError(componentName: string, existingPath: string, newPath: string): FrameworkError;
+    /**
+     * Create an import error
+     */
+    static createImportError(filePath: string, cause?: Error): FrameworkError;
+    /**
+     * Log error with appropriate level based on error type
+     */
+    static logError(error: FrameworkError, logger?: Console): void;
+    /**
+     * Check if an error is recoverable (app can continue running)
+     */
+    static isRecoverable(error: FrameworkError): boolean;
+    /**
+     * Collect and format multiple errors for reporting
+     */
+    static formatErrorSummary(errors: FrameworkError[]): string;
+}
+//# sourceMappingURL=ErrorHandler.d.ts.map

package/dist/core/ErrorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorHandler.d.ts","sourceRoot":"","sources":["../../src/core/ErrorHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAyC,MAAM,SAAS,CAAA;AAE/E;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,cAAc;IASzF;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAC5B,OAAO,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,MAAM,EACtB,QAAQ,CAAC,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,KAAK,GACZ,cAAc;IASjB;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,cAAc;IASvG;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,cAAc;IASpG;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,cAAc;IAS/E;;OAEG;IACH,MAAM,CAAC,2BAA2B,CAChC,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,KAAK,GACZ,cAAc;IAajB;;OAEG;IACH,MAAM,CAAC,uBAAuB,CAC5B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GACd,cAAc;IAcjB;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,cAAc;IASzE;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,GAAE,OAAiB,GAAG,IAAI;IAuBvE;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO;IAapD;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM;CAuB5D"}