@dbs-portal/core-module-registry/dist/utils/index.js

Core module registry system for automatic module discovery and registration

/**
 * Module Registry Utilities
 *
 * Utility functions and classes for module registry operations
 */
export { ModuleCache } from './ModuleCache';
export { BrowserEventEmitter, defaultEventEmitter } from './BrowserEventEmitter';
// Platform modules
export { getPath, getFs, getGlob, initializePlatformModules, preloadBrowserModules, getPlatformInfo, createPlatformError, clearModuleCache } from './platform-modules';
// Environment utilities
export { detectEnvironment, loadConditionalModule, loadConditionalModuleSync, getPathSeparator, getCurrentDirectory, isDevelopment, isProduction, isTest, isBrowser, isNode, getEnvironmentName, getPlatformName, createLogger, hasFeature, assertFeature, warnMissingFeature, ENV, FEATURES } from './environment';
// Module loading utilities
export const loadModuleAsync = async (modulePath) => {
    try {
        const module = await import(modulePath);
        return module.default || module;
    }
    catch (error) {
        console.error(`Failed to load module from ${modulePath}:`, error);
        throw error;
    }
};
// Module ID utilities
export const normalizeModuleId = (id) => {
    return id.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
};
export const isValidModuleId = (id) => {
    return /^[a-z0-9-]+$/.test(id) && id.length > 0 && !id.startsWith('-') && !id.endsWith('-');
};
// Path utilities
export const resolveModulePath = (baseDir, moduleId) => {
    return `${baseDir}/${moduleId}`;
};
export const getModulePackageName = (moduleId) => {
    return `@dbs-portal/module-${moduleId}`;
};
// Permission utilities
export const hasPermission = (userPermissions, requiredPermissions) => {
    if (requiredPermissions.length === 0)
        return true;
    return requiredPermissions.some(permission => userPermissions.includes(permission));
};
export const hasRole = (userRoles, requiredRoles) => {
    if (!requiredRoles || requiredRoles.length === 0)
        return true;
    return requiredRoles.some(role => userRoles.includes(role));
};
// Module filtering utilities
export const filterModulesByPermissions = (modules, userPermissions) => {
    return modules.filter(module => hasPermission(userPermissions, module.permissions));
};
export const filterModulesByRoles = (modules, userRoles) => {
    return modules.filter(module => hasRole(userRoles, module.roles || []));
};
// Sorting utilities
export const sortModulesByPriority = (modules) => {
    return [...modules].sort((a, b) => b.priority - a.priority);
};
export const sortModulesByName = (modules) => {
    return [...modules].sort((a, b) => a.name.localeCompare(b.name));
};
// Grouping utilities
export const groupModulesByCategory = (modules) => {
    return modules.reduce((groups, module) => {
        const category = module.category;
        if (!groups[category]) {
            groups[category] = [];
        }
        groups[category].push(module);
        return groups;
    }, {});
};
// Validation utilities
export const validateModuleId = (id) => {
    if (!id) {
        return { valid: false, error: 'Module ID is required' };
    }
    if (!isValidModuleId(id)) {
        return { valid: false, error: 'Module ID must be lowercase alphanumeric with hyphens' };
    }
    if (id.length > 50) {
        return { valid: false, error: 'Module ID must be 50 characters or less' };
    }
    return { valid: true };
};
// Dependency utilities
export const resolveDependencies = (modules) => {
    const moduleMap = new Map(modules.map(m => [m.id, m]));
    const resolved = [];
    const resolving = new Set();
    const resolved_ids = new Set();
    const resolve = (moduleId) => {
        if (resolved_ids.has(moduleId))
            return;
        if (resolving.has(moduleId)) {
            throw new Error(`Circular dependency detected: ${moduleId}`);
        }
        const module = moduleMap.get(moduleId);
        if (!module) {
            throw new Error(`Module not found: ${moduleId}`);
        }
        resolving.add(moduleId);
        // Resolve dependencies first
        for (const depId of module.dependencies) {
            resolve(depId);
        }
        resolving.delete(moduleId);
        resolved_ids.add(moduleId);
        resolved.push(module);
    };
    // Resolve all modules
    for (const module of modules) {
        resolve(module.id);
    }
    return resolved;
};
// Error handling utilities
export class ModuleRegistryError extends Error {
    moduleId;
    cause;
    constructor(message, moduleId, cause) {
        super(message);
        this.moduleId = moduleId;
        this.cause = cause;
        this.name = 'ModuleRegistryError';
    }
}
export class ModuleValidationError extends ModuleRegistryError {
    validationErrors;
    constructor(message, moduleId, validationErrors) {
        super(message, moduleId);
        this.validationErrors = validationErrors;
        this.name = 'ModuleValidationError';
    }
}
export class ModuleDiscoveryError extends ModuleRegistryError {
    source;
    constructor(message, source, cause) {
        super(message, undefined, cause);
        this.source = source;
        this.name = 'ModuleDiscoveryError';
    }
}
// Performance utilities
export const measurePerformance = async (operation, label) => {
    const start = performance.now();
    const result = await operation();
    const duration = performance.now() - start;
    console.debug(`${label} took ${duration.toFixed(2)}ms`);
    return { result, duration };
};
// Debounce utility for frequent operations
export const debounce = (func, wait) => {
    let timeout = null;
    return (...args) => {
        if (timeout) {
            clearTimeout(timeout);
        }
        timeout = setTimeout(() => {
            func(...args);
        }, wait);
    };
};
// Throttle utility for performance-sensitive operations
export const throttle = (func, limit) => {
    let inThrottle = false;
    return (...args) => {
        if (!inThrottle) {
            func(...args);
            inThrottle = true;
            setTimeout(() => {
                inThrottle = false;
            }, limit);
        }
    };
};
//# sourceMappingURL=index.js.map