@qiu_qiu/vue-auto-component-framework 1.0.0

package/dist/core/ErrorHandler.js

@@ -0,0 +1,124 @@
+import { FrameworkError, FrameworkErrorType } from '@/types';
+/**
+ * Error handler utility class for creating and managing framework errors
+ */
+export class ErrorHandler {
+    /**
+     * Create a component scan error
+     */
+    static createScanError(message, filePath, cause) {
+        return new FrameworkError(FrameworkErrorType.COMPONENT_SCAN_ERROR, message, { filePath }, cause);
+    }
+    /**
+     * Create a component registration error
+     */
+    static createRegistrationError(message, componentName, filePath, cause) {
+        return new FrameworkError(FrameworkErrorType.COMPONENT_REGISTER_ERROR, message, { componentName, filePath }, cause);
+    }
+    /**
+     * Create a layout initialization error
+     */
+    static createLayoutError(message, context, cause) {
+        return new FrameworkError(FrameworkErrorType.LAYOUT_INIT_ERROR, message, { context }, cause);
+    }
+    /**
+     * Create an app creation error
+     */
+    static createAppError(message, context, cause) {
+        return new FrameworkError(FrameworkErrorType.APP_CREATE_ERROR, message, { context }, cause);
+    }
+    /**
+     * Create a file not found error
+     */
+    static createFileNotFoundError(filePath, cause) {
+        return new FrameworkError(FrameworkErrorType.FILE_NOT_FOUND, `File not found: ${filePath}`, { filePath }, cause);
+    }
+    /**
+     * Create an invalid component error
+     */
+    static createInvalidComponentError(componentName, filePath, reason, cause) {
+        const message = reason
+            ? `Invalid component ${componentName}: ${reason}`
+            : `Invalid component: ${componentName}`;
+        return new FrameworkError(FrameworkErrorType.INVALID_COMPONENT, message, { componentName, filePath, context: { reason } }, cause);
+    }
+    /**
+     * Create a name conflict error
+     */
+    static createNameConflictError(componentName, existingPath, newPath) {
+        return new FrameworkError(FrameworkErrorType.NAME_CONFLICT, `Component name conflict: ${componentName} already exists`, {
+            componentName,
+            context: {
+                existingPath,
+                newPath
+            }
+        });
+    }
+    /**
+     * Create an import error
+     */
+    static createImportError(filePath, cause) {
+        return new FrameworkError(FrameworkErrorType.IMPORT_ERROR, `Failed to import component from ${filePath}`, { filePath }, cause);
+    }
+    /**
+     * Log error with appropriate level based on error type
+     */
+    static logError(error, logger = console) {
+        const errorInfo = error.getDetailedInfo();
+        switch (error.type) {
+            case FrameworkErrorType.APP_CREATE_ERROR:
+                logger.error(errorInfo);
+                break;
+            case FrameworkErrorType.LAYOUT_INIT_ERROR:
+                logger.error(errorInfo);
+                break;
+            case FrameworkErrorType.COMPONENT_SCAN_ERROR:
+            case FrameworkErrorType.COMPONENT_REGISTER_ERROR:
+            case FrameworkErrorType.FILE_NOT_FOUND:
+            case FrameworkErrorType.INVALID_COMPONENT:
+            case FrameworkErrorType.NAME_CONFLICT:
+            case FrameworkErrorType.IMPORT_ERROR:
+                logger.warn(errorInfo);
+                break;
+            default:
+                logger.error(errorInfo);
+        }
+    }
+    /**
+     * Check if an error is recoverable (app can continue running)
+     */
+    static isRecoverable(error) {
+        const recoverableTypes = [
+            FrameworkErrorType.COMPONENT_SCAN_ERROR,
+            FrameworkErrorType.COMPONENT_REGISTER_ERROR,
+            FrameworkErrorType.FILE_NOT_FOUND,
+            FrameworkErrorType.INVALID_COMPONENT,
+            FrameworkErrorType.NAME_CONFLICT,
+            FrameworkErrorType.IMPORT_ERROR
+        ];
+        return recoverableTypes.includes(error.type);
+    }
+    /**
+     * Collect and format multiple errors for reporting
+     */
+    static formatErrorSummary(errors) {
+        if (errors.length === 0) {
+            return 'No errors to report';
+        }
+        const summary = [
+            `Framework Error Summary (${errors.length} errors):`,
+            '='.repeat(50)
+        ];
+        errors.forEach((error, index) => {
+            summary.push(`\n${index + 1}. ${error.type}`);
+            summary.push(`   Message: ${error.message}`);
+            if (error.context.filePath) {
+                summary.push(`   File: ${error.context.filePath}`);
+            }
+            if (error.context.componentName) {
+                summary.push(`   Component: ${error.context.componentName}`);
+            }
+        });
+        return summary.join('\n');
+    }
+}

package/dist/core/FileScanner.d.ts

@@ -0,0 +1,26 @@
+import type { FileScanner as IFileScanner, ScanResult } from '@/types';
+/**
+ * File scanner implementation
+ * Handles scanning directories for component files
+ */
+export declare class FileScanner implements IFileScanner {
+    /**
+     * Scan directory for files with specified extensions
+     * Implements graceful error handling - missing directories don't fail the scan
+     */
+    scanDirectory(path: string, extensions: string[]): Promise<ScanResult>;
+    /**
+     * Recursively scan directory for files with specified extensions
+     * Continues scanning even when individual files/directories fail
+     */
+    private _scanDirectoryRecursive;
+    /**
+     * Check if directory should be skipped during scanning
+     */
+    private _shouldSkipDirectory;
+    /**
+     * Check if file has one of the valid extensions
+     */
+    private _hasValidExtension;
+}
+//# sourceMappingURL=FileScanner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileScanner.d.ts","sourceRoot":"","sources":["../../src/core/FileScanner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,IAAI,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGtE;;;GAGG;AACH,qBAAa,WAAY,YAAW,YAAY;IAC9C;;;OAGG;IACG,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAgC5E;;;OAGG;YACW,uBAAuB;IAgDrC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAG3B"}

package/dist/core/FileScanner.js

@@ -0,0 +1,102 @@
+import { readdir, stat, access } from 'fs/promises';
+import { join, resolve } from 'path';
+import { constants } from 'fs';
+import { ErrorHandler } from './ErrorHandler';
+/**
+ * File scanner implementation
+ * Handles scanning directories for component files
+ */
+export class FileScanner {
+    /**
+     * Scan directory for files with specified extensions
+     * Implements graceful error handling - missing directories don't fail the scan
+     */
+    async scanDirectory(path, extensions) {
+        const files = [];
+        const errors = [];
+        try {
+            const resolvedPath = resolve(path);
+            // Check if directory exists and is accessible
+            try {
+                await access(resolvedPath, constants.R_OK);
+            }
+            catch (error) {
+                // Directory doesn't exist or isn't readable - this is not a critical error
+                const accessError = ErrorHandler.createFileNotFoundError(resolvedPath, error);
+                errors.push(accessError);
+                console.info(`Components directory not found or not accessible: ${resolvedPath}`);
+                return { files, errors };
+            }
+            await this._scanDirectoryRecursive(resolvedPath, extensions, files, errors);
+            return { files, errors };
+        }
+        catch (error) {
+            // Critical scanning error
+            const scanError = ErrorHandler.createScanError(`Critical error during directory scan: ${error.message}`, path, error);
+            errors.push(scanError);
+            return { files, errors };
+        }
+    }
+    /**
+     * Recursively scan directory for files with specified extensions
+     * Continues scanning even when individual files/directories fail
+     */
+    async _scanDirectoryRecursive(dirPath, extensions, files, errors) {
+        try {
+            const entries = await readdir(dirPath);
+            for (const entry of entries) {
+                const fullPath = join(dirPath, entry);
+                try {
+                    const stats = await stat(fullPath);
+                    if (stats.isDirectory()) {
+                        // Skip node_modules and other common directories that shouldn't contain components
+                        if (this._shouldSkipDirectory(entry)) {
+                            continue;
+                        }
+                        // Recursively scan subdirectories
+                        await this._scanDirectoryRecursive(fullPath, extensions, files, errors);
+                    }
+                    else if (stats.isFile() && this._hasValidExtension(fullPath, extensions)) {
+                        files.push(fullPath);
+                    }
+                }
+                catch (error) {
+                    // Log individual file/directory errors but continue scanning
+                    const fileError = ErrorHandler.createScanError(`Failed to process file/directory: ${error.message}`, fullPath, error);
+                    errors.push(fileError);
+                    // Continue with next entry - don't let one bad file stop the whole scan
+                }
+            }
+        }
+        catch (error) {
+            // Directory access error - log but don't stop the scan
+            const dirError = ErrorHandler.createScanError(`Failed to read directory: ${error.message}`, dirPath, error);
+            errors.push(dirError);
+        }
+    }
+    /**
+     * Check if directory should be skipped during scanning
+     */
+    _shouldSkipDirectory(dirName) {
+        const skipDirs = [
+            'node_modules',
+            '.git',
+            '.svn',
+            '.hg',
+            'dist',
+            'build',
+            'coverage',
+            '.nyc_output',
+            '.cache',
+            'tmp',
+            'temp'
+        ];
+        return skipDirs.includes(dirName) || dirName.startsWith('.');
+    }
+    /**
+     * Check if file has one of the valid extensions
+     */
+    _hasValidExtension(filePath, extensions) {
+        return extensions.some(ext => filePath.endsWith(ext));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from 'vue';
+import type { FrameworkOptions } from '@/types';
+export type { FrameworkOptions, LayoutConfig, LayoutSlots, ComponentInfo, ScanResult } from '@/types';
+export { FrameworkError, FrameworkErrorType } from '@/types';
+export { ErrorHandler } from '@/core/ErrorHandler';
+export { ComponentRegistry } from '@/core/ComponentRegistry';
+export { FileScanner } from '@/core/FileScanner';
+export { ComponentScanner } from '@/core/ComponentScanner';
+export { AppCreator } from '@/core/AppCreator';
+export { default as DefaultLayout } from '@/layout/DefaultLayout.vue';
+export { LayoutManager } from '@/layout/LayoutManager';
+/**
+ * Create Vue app with framework features
+ * Compatible with Vue's native createApp API with enhanced error handling
+ */
+export declare function createApp(rootComponent?: Component, options?: FrameworkOptions): Promise<import("vue").App<any>>;
+declare const _default: {
+    createApp: typeof createApp;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AACpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAI/C,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,aAAa,EACb,UAAU,EACX,MAAM,SAAS,CAAA;AAEhB,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAGlD,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAG9C,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,4BAA4B,CAAA;AACrE,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAEtD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,aAAa,CAAC,EAAE,SAAS,EAAE,OAAO,GAAE,gBAAqB,mCAkBxF;;;;AAGD,wBAEC"}

package/dist/index.js

@@ -0,0 +1,34 @@
+import { AppCreator } from '@/core/AppCreator';
+export { FrameworkError, FrameworkErrorType } from '@/types';
+export { ErrorHandler } from '@/core/ErrorHandler';
+// Export core classes
+export { ComponentRegistry } from '@/core/ComponentRegistry';
+export { FileScanner } from '@/core/FileScanner';
+export { ComponentScanner } from '@/core/ComponentScanner';
+export { AppCreator } from '@/core/AppCreator';
+// Export layout components
+export { default as DefaultLayout } from '@/layout/DefaultLayout.vue';
+export { LayoutManager } from '@/layout/LayoutManager';
+/**
+ * Create Vue app with framework features
+ * Compatible with Vue's native createApp API with enhanced error handling
+ */
+export async function createApp(rootComponent, options = {}) {
+    try {
+        const appCreator = new AppCreator();
+        return await appCreator.createApp(rootComponent, options);
+    }
+    catch (error) {
+        // If AppCreator throws a FrameworkError, preserve it
+        if (error instanceof Error && error.name === 'FrameworkError') {
+            throw error;
+        }
+        // Otherwise, wrap in a framework error
+        const { ErrorHandler } = await import('@/core/ErrorHandler');
+        throw ErrorHandler.createAppError('Failed to create application', { rootComponent: rootComponent?.name || 'anonymous' }, error);
+    }
+}
+// Default export for convenience
+export default {
+    createApp
+};

package/dist/layout/LayoutManager.d.ts

@@ -0,0 +1,56 @@
+import type { App, Component } from 'vue';
+import type { LayoutConfig } from '@/types';
+/**
+ * Layout manager handles layout configuration and registration
+ */
+export declare class LayoutManager {
+    private defaultConfig;
+    private currentConfig;
+    private customLayouts;
+    constructor(initialConfig?: LayoutConfig);
+    /**
+     * Merge default config with custom config, allowing overrides
+     */
+    private mergeConfig;
+    /**
+     * Get current layout configuration
+     */
+    getConfig(): Required<LayoutConfig>;
+    /**
+     * Update layout configuration with override mechanism
+     */
+    updateConfig(newConfig: LayoutConfig): void;
+    /**
+     * Reset configuration to default values
+     */
+    resetConfig(): void;
+    /**
+     * Register a custom layout component
+     */
+    registerLayout(name: string, component: Component): void;
+    /**
+     * Get a registered layout component
+     */
+    getLayout(name: string): Component | undefined;
+    /**
+     * Get all registered custom layouts
+     */
+    getAllLayouts(): Map<string, Component>;
+    /**
+     * Check if a layout is registered
+     */
+    hasLayout(name: string): boolean;
+    /**
+     * Initialize layout system in Vue app
+     */
+    initializeLayouts(app: App): void;
+    /**
+     * Create a layout configuration with validation
+     */
+    static createConfig(config?: LayoutConfig): Required<LayoutConfig>;
+    /**
+     * Validate layout configuration
+     */
+    static validateConfig(config: LayoutConfig): boolean;
+}
+//# sourceMappingURL=LayoutManager.d.ts.map

package/dist/layout/LayoutManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutManager.d.ts","sourceRoot":"","sources":["../../src/layout/LayoutManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAI3C;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,aAAa,CAKpB;IAED,OAAO,CAAC,aAAa,CAAwB;IAC7C,OAAO,CAAC,aAAa,CAAoC;gBAE7C,aAAa,CAAC,EAAE,YAAY;IAIxC;;OAEG;IACH,OAAO,CAAC,WAAW;IAgBnB;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,YAAY,CAAC;IAInC;;OAEG;IACH,YAAY,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAI3C;;OAEG;IACH,WAAW,IAAI,IAAI;IAInB;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAoBxD;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI9C;;OAEG;IACH,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC;IAIvC;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIhC;;OAEG;IACH,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI;IAgDjC;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,MAAM,GAAE,YAAiB,GAAG,QAAQ,CAAC,YAAY,CAAC;IAKtE;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO;CAwBrD"}

package/dist/layout/LayoutManager.js

@@ -0,0 +1,146 @@
+import { FrameworkError, FrameworkErrorType } from '@/types';
+import DefaultLayout from './DefaultLayout.vue';
+/**
+ * Layout manager handles layout configuration and registration
+ */
+export class LayoutManager {
+    constructor(initialConfig) {
+        this.defaultConfig = {
+            header: true,
+            sidebar: true,
+            footer: true,
+            responsive: true
+        };
+        this.customLayouts = new Map();
+        this.currentConfig = this.mergeConfig(this.defaultConfig, initialConfig);
+    }
+    /**
+     * Merge default config with custom config, allowing overrides
+     */
+    mergeConfig(defaultConfig, customConfig) {
+        if (!customConfig) {
+            return { ...defaultConfig };
+        }
+        return {
+            header: customConfig.header !== undefined ? customConfig.header : defaultConfig.header,
+            sidebar: customConfig.sidebar !== undefined ? customConfig.sidebar : defaultConfig.sidebar,
+            footer: customConfig.footer !== undefined ? customConfig.footer : defaultConfig.footer,
+            responsive: customConfig.responsive !== undefined ? customConfig.responsive : defaultConfig.responsive
+        };
+    }
+    /**
+     * Get current layout configuration
+     */
+    getConfig() {
+        return { ...this.currentConfig };
+    }
+    /**
+     * Update layout configuration with override mechanism
+     */
+    updateConfig(newConfig) {
+        this.currentConfig = this.mergeConfig(this.currentConfig, newConfig);
+    }
+    /**
+     * Reset configuration to default values
+     */
+    resetConfig() {
+        this.currentConfig = { ...this.defaultConfig };
+    }
+    /**
+     * Register a custom layout component
+     */
+    registerLayout(name, component) {
+        if (!name || typeof name !== 'string') {
+            throw new FrameworkError(FrameworkErrorType.LAYOUT_INIT_ERROR, 'Layout name must be a non-empty string', { context: { layoutName: name } });
+        }
+        if (!component) {
+            throw new FrameworkError(FrameworkErrorType.LAYOUT_INIT_ERROR, 'Layout component cannot be null or undefined', { context: { layoutName: name } });
+        }
+        this.customLayouts.set(name, component);
+    }
+    /**
+     * Get a registered layout component
+     */
+    getLayout(name) {
+        return this.customLayouts.get(name);
+    }
+    /**
+     * Get all registered custom layouts
+     */
+    getAllLayouts() {
+        return new Map(this.customLayouts);
+    }
+    /**
+     * Check if a layout is registered
+     */
+    hasLayout(name) {
+        return this.customLayouts.has(name);
+    }
+    /**
+     * Initialize layout system in Vue app
+     */
+    initializeLayouts(app) {
+        try {
+            // Register default layout with current configuration
+            const DefaultLayoutWithConfig = {
+                ...DefaultLayout,
+                props: {
+                    ...DefaultLayout.props,
+                    config: {
+                        type: Object,
+                        default: () => this.currentConfig
+                    }
+                }
+            };
+            app.component('DefaultLayout', DefaultLayoutWithConfig);
+            // Register all custom layouts
+            for (const [name, component] of this.customLayouts) {
+                try {
+                    app.component(name, component);
+                }
+                catch (error) {
+                    throw new FrameworkError(FrameworkErrorType.LAYOUT_INIT_ERROR, `Failed to register custom layout: ${name}`, { context: { layoutName: name } }, error);
+                }
+            }
+            // Provide layout configuration globally
+            app.provide('layoutConfig', this.currentConfig);
+            app.provide('layoutManager', this);
+        }
+        catch (error) {
+            if (error instanceof FrameworkError) {
+                throw error;
+            }
+            throw new FrameworkError(FrameworkErrorType.LAYOUT_INIT_ERROR, 'Failed to initialize layout system', {}, error);
+        }
+    }
+    /**
+     * Create a layout configuration with validation
+     */
+    static createConfig(config = {}) {
+        const manager = new LayoutManager(config);
+        return manager.getConfig();
+    }
+    /**
+     * Validate layout configuration
+     */
+    static validateConfig(config) {
+        if (typeof config !== 'object' || config === null) {
+            return false;
+        }
+        const validKeys = ['header', 'sidebar', 'footer', 'responsive'];
+        const configKeys = Object.keys(config);
+        // Check for invalid keys
+        for (const key of configKeys) {
+            if (!validKeys.includes(key)) {
+                return false;
+            }
+        }
+        // Check for valid boolean values
+        for (const [key, value] of Object.entries(config)) {
+            if (value !== undefined && typeof value !== 'boolean') {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/layout/index.d.ts

@@ -0,0 +1,4 @@
+export { default as DefaultLayout } from './DefaultLayout.vue';
+export { LayoutManager } from './LayoutManager';
+export type { LayoutConfig, LayoutSlots } from '@/types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/layout/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA"}

package/dist/layout/index.js

@@ -0,0 +1,2 @@
+export { default as DefaultLayout } from './DefaultLayout.vue';
+export { LayoutManager } from './LayoutManager';

package/dist/types/index.d.ts

@@ -0,0 +1,140 @@
+import type { App, Component, Plugin } from 'vue';
+/**
+ * Framework configuration options
+ */
+export interface FrameworkOptions {
+    /** Path to components directory, defaults to '@/components' */
+    componentsPath?: string;
+    /** Layout configuration */
+    layoutConfig?: LayoutConfig;
+    /** Additional Vue plugins to install */
+    plugins?: Plugin[];
+}
+/**
+ * Layout configuration interface
+ */
+export interface LayoutConfig {
+    /** Enable header section */
+    header?: boolean;
+    /** Enable sidebar section */
+    sidebar?: boolean;
+    /** Enable footer section */
+    footer?: boolean;
+    /** Enable responsive design */
+    responsive?: boolean;
+}
+/**
+ * Layout slots interface
+ */
+export interface LayoutSlots {
+    /** Header slot */
+    header?: any;
+    /** Sidebar slot */
+    sidebar?: any;
+    /** Main content slot (required) */
+    main: any;
+    /** Footer slot */
+    footer?: any;
+}
+/**
+ * Component information interface
+ */
+export interface ComponentInfo {
+    /** Component name */
+    name: string;
+    /** Vue component */
+    component: Component;
+    /** File path */
+    path: string;
+}
+/**
+ * File scan result interface
+ */
+export interface ScanResult {
+    /** Array of found file paths */
+    files: string[];
+    /** Array of errors encountered during scanning */
+    errors: Error[];
+}
+/**
+ * Framework error types
+ */
+export declare enum FrameworkErrorType {
+    COMPONENT_SCAN_ERROR = "COMPONENT_SCAN_ERROR",
+    COMPONENT_REGISTER_ERROR = "COMPONENT_REGISTER_ERROR",
+    LAYOUT_INIT_ERROR = "LAYOUT_INIT_ERROR",
+    APP_CREATE_ERROR = "APP_CREATE_ERROR",
+    FILE_NOT_FOUND = "FILE_NOT_FOUND",
+    INVALID_COMPONENT = "INVALID_COMPONENT",
+    NAME_CONFLICT = "NAME_CONFLICT",
+    IMPORT_ERROR = "IMPORT_ERROR"
+}
+/**
+ * Error context interface for detailed error information
+ */
+export interface ErrorContext {
+    /** File path where error occurred */
+    filePath?: string;
+    /** Component name involved in error */
+    componentName?: string;
+    /** Additional context data */
+    context?: Record<string, any>;
+    /** Timestamp when error occurred */
+    timestamp?: Date;
+    /** Stack trace from original error */
+    originalStack?: string;
+}
+/**
+ * Framework error class with detailed error information
+ */
+export declare class FrameworkError extends Error {
+    readonly type: FrameworkErrorType;
+    readonly cause?: Error | undefined;
+    readonly timestamp: Date;
+    readonly context: ErrorContext;
+    constructor(type: FrameworkErrorType, message: string, context?: ErrorContext, cause?: Error | undefined);
+    /**
+     * Generate detailed error information for debugging
+     */
+    getDetailedInfo(): string;
+    /**
+     * Convert error to JSON for logging
+     */
+    toJSON(): Record<string, any>;
+}
+/**
+ * Component scanner interface
+ */
+export interface ComponentScanner {
+    /** Scan components in the specified base path */
+    scanComponents(basePath: string): Promise<ComponentInfo[]>;
+    /** Register components in the Vue app */
+    registerComponents(app: App, components: ComponentInfo[]): void;
+}
+/**
+ * Component registry interface
+ */
+export interface ComponentRegistry {
+    /** Register a component */
+    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;
+}
+/**
+ * File scanner interface
+ */
+export interface FileScanner {
+    /** Scan directory for files with specified extensions */
+    scanDirectory(path: string, extensions: string[]): Promise<ScanResult>;
+}
+//# sourceMappingURL=index.d.ts.map