@memberjunction/react-runtime 2.70.0

package/dist/index.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactRuntime = exports.DEFAULT_CONFIGS = exports.VERSION = exports.countComponentsInHierarchy = exports.flattenComponentHierarchy = exports.validateComponentSpec = exports.registerComponentHierarchy = exports.ComponentHierarchyRegistrar = exports.extractPropPaths = exports.wrapCallbacksWithLogging = exports.createPropsTransformer = exports.mergeProps = exports.validateComponentProps = exports.normalizeStyles = exports.normalizeCallbacks = exports.buildComponentProps = exports.portalComponent = exports.withErrorHandler = exports.conditionalComponent = exports.injectProps = exports.lazyComponent = exports.memoizeComponent = exports.wrapComponent = exports.createErrorLogger = exports.formatComponentError = exports.withErrorBoundary = exports.createErrorBoundary = exports.ComponentResolver = exports.ComponentRegistry = exports.getJSXConfig = exports.validateBabelPresets = exports.getBabelConfig = exports.DEVELOPMENT_CONFIG = exports.PRODUCTION_CONFIG = exports.DEFAULT_PLUGINS = exports.DEFAULT_PRESETS = exports.ComponentCompiler = void 0;
+const compiler_1 = require("./compiler");
+const registry_1 = require("./registry");
+const registry_2 = require("./registry");
+__exportStar(require("./types"), exports);
+var compiler_2 = require("./compiler");
+Object.defineProperty(exports, "ComponentCompiler", { enumerable: true, get: function () { return compiler_2.ComponentCompiler; } });
+var compiler_3 = require("./compiler");
+Object.defineProperty(exports, "DEFAULT_PRESETS", { enumerable: true, get: function () { return compiler_3.DEFAULT_PRESETS; } });
+Object.defineProperty(exports, "DEFAULT_PLUGINS", { enumerable: true, get: function () { return compiler_3.DEFAULT_PLUGINS; } });
+Object.defineProperty(exports, "PRODUCTION_CONFIG", { enumerable: true, get: function () { return compiler_3.PRODUCTION_CONFIG; } });
+Object.defineProperty(exports, "DEVELOPMENT_CONFIG", { enumerable: true, get: function () { return compiler_3.DEVELOPMENT_CONFIG; } });
+Object.defineProperty(exports, "getBabelConfig", { enumerable: true, get: function () { return compiler_3.getBabelConfig; } });
+Object.defineProperty(exports, "validateBabelPresets", { enumerable: true, get: function () { return compiler_3.validateBabelPresets; } });
+Object.defineProperty(exports, "getJSXConfig", { enumerable: true, get: function () { return compiler_3.getJSXConfig; } });
+var registry_3 = require("./registry");
+Object.defineProperty(exports, "ComponentRegistry", { enumerable: true, get: function () { return registry_3.ComponentRegistry; } });
+var registry_4 = require("./registry");
+Object.defineProperty(exports, "ComponentResolver", { enumerable: true, get: function () { return registry_4.ComponentResolver; } });
+var runtime_1 = require("./runtime");
+Object.defineProperty(exports, "createErrorBoundary", { enumerable: true, get: function () { return runtime_1.createErrorBoundary; } });
+Object.defineProperty(exports, "withErrorBoundary", { enumerable: true, get: function () { return runtime_1.withErrorBoundary; } });
+Object.defineProperty(exports, "formatComponentError", { enumerable: true, get: function () { return runtime_1.formatComponentError; } });
+Object.defineProperty(exports, "createErrorLogger", { enumerable: true, get: function () { return runtime_1.createErrorLogger; } });
+var runtime_2 = require("./runtime");
+Object.defineProperty(exports, "wrapComponent", { enumerable: true, get: function () { return runtime_2.wrapComponent; } });
+Object.defineProperty(exports, "memoizeComponent", { enumerable: true, get: function () { return runtime_2.memoizeComponent; } });
+Object.defineProperty(exports, "lazyComponent", { enumerable: true, get: function () { return runtime_2.lazyComponent; } });
+Object.defineProperty(exports, "injectProps", { enumerable: true, get: function () { return runtime_2.injectProps; } });
+Object.defineProperty(exports, "conditionalComponent", { enumerable: true, get: function () { return runtime_2.conditionalComponent; } });
+Object.defineProperty(exports, "withErrorHandler", { enumerable: true, get: function () { return runtime_2.withErrorHandler; } });
+Object.defineProperty(exports, "portalComponent", { enumerable: true, get: function () { return runtime_2.portalComponent; } });
+var runtime_3 = require("./runtime");
+Object.defineProperty(exports, "buildComponentProps", { enumerable: true, get: function () { return runtime_3.buildComponentProps; } });
+Object.defineProperty(exports, "normalizeCallbacks", { enumerable: true, get: function () { return runtime_3.normalizeCallbacks; } });
+Object.defineProperty(exports, "normalizeStyles", { enumerable: true, get: function () { return runtime_3.normalizeStyles; } });
+Object.defineProperty(exports, "validateComponentProps", { enumerable: true, get: function () { return runtime_3.validateComponentProps; } });
+Object.defineProperty(exports, "mergeProps", { enumerable: true, get: function () { return runtime_3.mergeProps; } });
+Object.defineProperty(exports, "createPropsTransformer", { enumerable: true, get: function () { return runtime_3.createPropsTransformer; } });
+Object.defineProperty(exports, "wrapCallbacksWithLogging", { enumerable: true, get: function () { return runtime_3.wrapCallbacksWithLogging; } });
+Object.defineProperty(exports, "extractPropPaths", { enumerable: true, get: function () { return runtime_3.extractPropPaths; } });
+var runtime_4 = require("./runtime");
+Object.defineProperty(exports, "ComponentHierarchyRegistrar", { enumerable: true, get: function () { return runtime_4.ComponentHierarchyRegistrar; } });
+Object.defineProperty(exports, "registerComponentHierarchy", { enumerable: true, get: function () { return runtime_4.registerComponentHierarchy; } });
+Object.defineProperty(exports, "validateComponentSpec", { enumerable: true, get: function () { return runtime_4.validateComponentSpec; } });
+Object.defineProperty(exports, "flattenComponentHierarchy", { enumerable: true, get: function () { return runtime_4.flattenComponentHierarchy; } });
+Object.defineProperty(exports, "countComponentsInHierarchy", { enumerable: true, get: function () { return runtime_4.countComponentsInHierarchy; } });
+exports.VERSION = '2.69.1';
+exports.DEFAULT_CONFIGS = {
+    compiler: {
+        babel: {
+            presets: ['react'],
+            plugins: []
+        },
+        minify: false,
+        sourceMaps: false,
+        cache: true,
+        maxCacheSize: 100
+    },
+    registry: {
+        maxComponents: 1000,
+        cleanupInterval: 60000,
+        useLRU: true,
+        enableNamespaces: true
+    }
+};
+function createReactRuntime(babelInstance, config) {
+    const compiler = new compiler_1.ComponentCompiler(config?.compiler);
+    compiler.setBabelInstance(babelInstance);
+    const registry = new registry_1.ComponentRegistry(config?.registry);
+    const resolver = new registry_2.ComponentResolver(registry);
+    return {
+        compiler,
+        registry,
+        resolver,
+        version: exports.VERSION
+    };
+}
+exports.createReactRuntime = createReactRuntime;

package/dist/registry/component-registry.d.ts

@@ -0,0 +1,32 @@
+import { ComponentMetadata, RegistryConfig } from '../types';
+export declare class ComponentRegistry {
+    private registry;
+    private config;
+    private cleanupTimer?;
+    constructor(config?: Partial<RegistryConfig>);
+    register(name: string, component: any, namespace?: string, version?: string, tags?: string[]): ComponentMetadata;
+    get(name: string, namespace?: string, version?: string): any;
+    has(name: string, namespace?: string, version?: string): boolean;
+    unregister(name: string, namespace?: string, version?: string): boolean;
+    getNamespace(namespace: string): ComponentMetadata[];
+    getNamespaces(): string[];
+    getByTags(tags: string[]): ComponentMetadata[];
+    release(name: string, namespace?: string, version?: string): void;
+    clear(): void;
+    size(): number;
+    cleanup(force?: boolean): number;
+    getStats(): {
+        totalComponents: number;
+        namespaces: number;
+        totalRefCount: number;
+        oldestComponent?: Date;
+        newestComponent?: Date;
+    };
+    destroy(): void;
+    private generateRegistryKey;
+    private findLatestVersion;
+    private evictLRU;
+    private startCleanupTimer;
+    private stopCleanupTimer;
+}
+//# sourceMappingURL=component-registry.d.ts.map

package/dist/registry/component-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-registry.d.ts","sourceRoot":"","sources":["../../src/registry/component-registry.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,iBAAiB,EACjB,cAAc,EACf,MAAM,UAAU,CAAC;AAgBlB,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,YAAY,CAAC,CAA0B;gBAMnC,MAAM,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC;IAmB5C,QAAQ,CACN,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,EACd,SAAS,GAAE,MAAiB,EAC5B,OAAO,GAAE,MAAa,EACtB,IAAI,CAAC,EAAE,MAAM,EAAE,GACd,iBAAiB;IAuCpB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAiB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,GAAG;IAyBtE,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAiB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO;IAe1E,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAiB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO;IAejF,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,iBAAiB,EAAE;IAgBpD,aAAa,IAAI,MAAM,EAAE;IAezB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,iBAAiB,EAAE;IAkB9C,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,GAAE,MAAiB,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAgB3E,KAAK,IAAI,IAAI;IAQb,IAAI,IAAI,MAAM;IASd,OAAO,CAAC,KAAK,GAAE,OAAe,GAAG,MAAM;IAyBvC,QAAQ,IAAI;QACV,eAAe,EAAE,MAAM,CAAC;QACxB,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,CAAC,EAAE,IAAI,CAAC;QACvB,eAAe,CAAC,EAAE,IAAI,CAAC;KACxB;IA6BD,OAAO,IAAI,IAAI;IAYf,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,QAAQ;IAsBhB,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,gBAAgB;CAMzB"}

package/dist/registry/component-registry.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentRegistry = void 0;
+const DEFAULT_REGISTRY_CONFIG = {
+    maxComponents: 1000,
+    cleanupInterval: 60000,
+    useLRU: true,
+    enableNamespaces: true
+};
+class ComponentRegistry {
+    constructor(config) {
+        this.config = { ...DEFAULT_REGISTRY_CONFIG, ...config };
+        this.registry = new Map();
+        if (this.config.cleanupInterval > 0) {
+            this.startCleanupTimer();
+        }
+    }
+    register(name, component, namespace = 'Global', version = 'v1', tags) {
+        const id = this.generateRegistryKey(name, namespace, version);
+        const metadata = {
+            id,
+            name,
+            version,
+            namespace,
+            registeredAt: new Date(),
+            tags
+        };
+        const entry = {
+            component,
+            metadata,
+            lastAccessed: new Date(),
+            refCount: 0
+        };
+        if (this.registry.size >= this.config.maxComponents && this.config.useLRU) {
+            this.evictLRU();
+        }
+        this.registry.set(id, entry);
+        return metadata;
+    }
+    get(name, namespace = 'Global', version) {
+        const id = version
+            ? this.generateRegistryKey(name, namespace, version)
+            : this.findLatestVersion(name, namespace);
+        if (!id)
+            return undefined;
+        const entry = this.registry.get(id);
+        if (entry) {
+            entry.lastAccessed = new Date();
+            entry.refCount++;
+            return entry.component;
+        }
+        return undefined;
+    }
+    has(name, namespace = 'Global', version) {
+        const id = version
+            ? this.generateRegistryKey(name, namespace, version)
+            : this.findLatestVersion(name, namespace);
+        return id ? this.registry.has(id) : false;
+    }
+    unregister(name, namespace = 'Global', version) {
+        const id = version
+            ? this.generateRegistryKey(name, namespace, version)
+            : this.findLatestVersion(name, namespace);
+        if (!id)
+            return false;
+        return this.registry.delete(id);
+    }
+    getNamespace(namespace) {
+        const components = [];
+        for (const entry of this.registry.values()) {
+            if (entry.metadata.namespace === namespace) {
+                components.push(entry.metadata);
+            }
+        }
+        return components;
+    }
+    getNamespaces() {
+        const namespaces = new Set();
+        for (const entry of this.registry.values()) {
+            namespaces.add(entry.metadata.namespace);
+        }
+        return Array.from(namespaces);
+    }
+    getByTags(tags) {
+        const components = [];
+        for (const entry of this.registry.values()) {
+            if (entry.metadata.tags?.some(tag => tags.includes(tag))) {
+                components.push(entry.metadata);
+            }
+        }
+        return components;
+    }
+    release(name, namespace = 'Global', version) {
+        const id = version
+            ? this.generateRegistryKey(name, namespace, version)
+            : this.findLatestVersion(name, namespace);
+        if (!id)
+            return;
+        const entry = this.registry.get(id);
+        if (entry && entry.refCount > 0) {
+            entry.refCount--;
+        }
+    }
+    clear() {
+        this.registry.clear();
+    }
+    size() {
+        return this.registry.size;
+    }
+    cleanup(force = false) {
+        const toRemove = [];
+        const now = Date.now();
+        for (const [id, entry] of this.registry) {
+            const timeSinceAccess = now - entry.lastAccessed.getTime();
+            const isUnused = entry.refCount === 0 && timeSinceAccess > this.config.cleanupInterval;
+            if (force || isUnused) {
+                toRemove.push(id);
+            }
+        }
+        for (const id of toRemove) {
+            this.registry.delete(id);
+        }
+        return toRemove.length;
+    }
+    getStats() {
+        let totalRefCount = 0;
+        let oldest;
+        let newest;
+        for (const entry of this.registry.values()) {
+            totalRefCount += entry.refCount;
+            if (!oldest || entry.metadata.registeredAt < oldest) {
+                oldest = entry.metadata.registeredAt;
+            }
+            if (!newest || entry.metadata.registeredAt > newest) {
+                newest = entry.metadata.registeredAt;
+            }
+        }
+        return {
+            totalComponents: this.registry.size,
+            namespaces: this.getNamespaces().length,
+            totalRefCount,
+            oldestComponent: oldest,
+            newestComponent: newest
+        };
+    }
+    destroy() {
+        this.stopCleanupTimer();
+        this.clear();
+    }
+    generateRegistryKey(name, namespace, version) {
+        if (this.config.enableNamespaces) {
+            return `${namespace}::${name}@${version}`;
+        }
+        return `${name}@${version}`;
+    }
+    findLatestVersion(name, namespace) {
+        let latestKey;
+        let latestDate;
+        for (const [key, entry] of this.registry) {
+            if (entry.metadata.name === name &&
+                entry.metadata.namespace === namespace) {
+                if (!latestDate || entry.metadata.registeredAt > latestDate) {
+                    latestDate = entry.metadata.registeredAt;
+                    latestKey = key;
+                }
+            }
+        }
+        return latestKey;
+    }
+    evictLRU() {
+        let lruKey;
+        let lruTime;
+        for (const [key, entry] of this.registry) {
+            if (entry.refCount > 0)
+                continue;
+            if (!lruTime || entry.lastAccessed < lruTime) {
+                lruTime = entry.lastAccessed;
+                lruKey = key;
+            }
+        }
+        if (lruKey) {
+            this.registry.delete(lruKey);
+        }
+    }
+    startCleanupTimer() {
+        this.cleanupTimer = setInterval(() => {
+            this.cleanup();
+        }, this.config.cleanupInterval);
+    }
+    stopCleanupTimer() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+    }
+}
+exports.ComponentRegistry = ComponentRegistry;

package/dist/registry/component-resolver.d.ts

@@ -0,0 +1,29 @@
+import { ComponentRegistry } from './component-registry';
+export interface ComponentSpec {
+    componentName: string;
+    componentCode?: string;
+    childComponents?: ComponentSpec[];
+    components?: ComponentSpec[];
+}
+export interface ResolvedComponents {
+    [componentName: string]: any;
+}
+export declare class ComponentResolver {
+    private registry;
+    constructor(registry: ComponentRegistry);
+    resolveComponents(spec: ComponentSpec, namespace?: string): ResolvedComponents;
+    private resolveComponentHierarchy;
+    validateDependencies(spec: ComponentSpec, namespace?: string): string[];
+    private checkDependencies;
+    getDependencyGraph(spec: ComponentSpec): Map<string, string[]>;
+    private buildDependencyGraph;
+    getLoadOrder(spec: ComponentSpec): string[];
+    private topologicalSortDFS;
+    resolveInOrder(spec: ComponentSpec, namespace?: string): Array<{
+        name: string;
+        component: any;
+    }>;
+    flattenComponentSpecs(spec: ComponentSpec): ComponentSpec[];
+    private collectComponentSpecs;
+}
+//# sourceMappingURL=component-resolver.d.ts.map

package/dist/registry/component-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-resolver.d.ts","sourceRoot":"","sources":["../../src/registry/component-resolver.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAKzD,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,aAAa,EAAE,CAAC;IAClC,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;CAC9B;AAKD,MAAM,WAAW,kBAAkB;IACjC,CAAC,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC;CAC9B;AAMD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAoB;gBAMxB,QAAQ,EAAE,iBAAiB;IAUvC,iBAAiB,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,GAAE,MAAiB,GAAG,kBAAkB;IAgBxF,OAAO,CAAC,yBAAyB;IAgCjC,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,GAAE,MAAiB,GAAG,MAAM,EAAE;IAgBjF,OAAO,CAAC,iBAAiB;IA0BzB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAe9D,OAAO,CAAC,oBAAoB;IAwB5B,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,EAAE;IAuB3C,OAAO,CAAC,kBAAkB;IAwB1B,cAAc,CAAC,IAAI,EAAE,aAAa,EAAE,SAAS,GAAE,MAAiB,GAAG,KAAK,CAAC;QACvE,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,GAAG,CAAC;KAChB,CAAC;IAmBF,qBAAqB,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,EAAE;IAe3D,OAAO,CAAC,qBAAqB;CAe9B"}

package/dist/registry/component-resolver.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentResolver = void 0;
+class ComponentResolver {
+    constructor(registry) {
+        this.registry = registry;
+    }
+    resolveComponents(spec, namespace = 'Global') {
+        const resolved = {};
+        this.resolveComponentHierarchy(spec, resolved, namespace);
+        return resolved;
+    }
+    resolveComponentHierarchy(spec, resolved, namespace, visited = new Set()) {
+        if (visited.has(spec.componentName)) {
+            console.warn(`Circular dependency detected for component: ${spec.componentName}`);
+            return;
+        }
+        visited.add(spec.componentName);
+        const component = this.registry.get(spec.componentName, namespace);
+        if (component) {
+            resolved[spec.componentName] = component;
+        }
+        const children = spec.childComponents || spec.components || [];
+        for (const child of children) {
+            this.resolveComponentHierarchy(child, resolved, namespace, visited);
+        }
+    }
+    validateDependencies(spec, namespace = 'Global') {
+        const missing = [];
+        const checked = new Set();
+        this.checkDependencies(spec, namespace, missing, checked);
+        return missing;
+    }
+    checkDependencies(spec, namespace, missing, checked) {
+        if (checked.has(spec.componentName))
+            return;
+        checked.add(spec.componentName);
+        if (!this.registry.has(spec.componentName, namespace)) {
+            missing.push(spec.componentName);
+        }
+        const children = spec.childComponents || spec.components || [];
+        for (const child of children) {
+            this.checkDependencies(child, namespace, missing, checked);
+        }
+    }
+    getDependencyGraph(spec) {
+        const graph = new Map();
+        const visited = new Set();
+        this.buildDependencyGraph(spec, graph, visited);
+        return graph;
+    }
+    buildDependencyGraph(spec, graph, visited) {
+        if (visited.has(spec.componentName))
+            return;
+        visited.add(spec.componentName);
+        const children = spec.childComponents || spec.components || [];
+        const dependencies = children.map(child => child.componentName);
+        graph.set(spec.componentName, dependencies);
+        for (const child of children) {
+            this.buildDependencyGraph(child, graph, visited);
+        }
+    }
+    getLoadOrder(spec) {
+        const graph = this.getDependencyGraph(spec);
+        const visited = new Set();
+        const stack = [];
+        for (const node of graph.keys()) {
+            if (!visited.has(node)) {
+                this.topologicalSortDFS(node, graph, visited, stack);
+            }
+        }
+        return stack.reverse();
+    }
+    topologicalSortDFS(node, graph, visited, stack) {
+        visited.add(node);
+        const dependencies = graph.get(node) || [];
+        for (const dep of dependencies) {
+            if (!visited.has(dep)) {
+                this.topologicalSortDFS(dep, graph, visited, stack);
+            }
+        }
+        stack.push(node);
+    }
+    resolveInOrder(spec, namespace = 'Global') {
+        const loadOrder = this.getLoadOrder(spec);
+        const resolved = [];
+        for (const name of loadOrder) {
+            const component = this.registry.get(name, namespace);
+            if (component) {
+                resolved.push({ name, component });
+            }
+        }
+        return resolved;
+    }
+    flattenComponentSpecs(spec) {
+        const flattened = [];
+        const visited = new Set();
+        this.collectComponentSpecs(spec, flattened, visited);
+        return flattened;
+    }
+    collectComponentSpecs(spec, collected, visited) {
+        if (visited.has(spec.componentName))
+            return;
+        visited.add(spec.componentName);
+        collected.push(spec);
+        const children = spec.childComponents || spec.components || [];
+        for (const child of children) {
+            this.collectComponentSpecs(child, collected, visited);
+        }
+    }
+}
+exports.ComponentResolver = ComponentResolver;

package/dist/registry/index.d.ts

@@ -0,0 +1,3 @@
+export { ComponentRegistry } from './component-registry';
+export { ComponentResolver, ComponentSpec, ResolvedComponents } from './component-resolver';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/registry/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComponentResolver = exports.ComponentRegistry = void 0;
+var component_registry_1 = require("./component-registry");
+Object.defineProperty(exports, "ComponentRegistry", { enumerable: true, get: function () { return component_registry_1.ComponentRegistry; } });
+var component_resolver_1 = require("./component-resolver");
+Object.defineProperty(exports, "ComponentResolver", { enumerable: true, get: function () { return component_resolver_1.ComponentResolver; } });

package/dist/runtime/component-hierarchy.d.ts

@@ -0,0 +1,44 @@
+import { ComponentStyles, RuntimeContext } from '../types';
+import { ComponentCompiler } from '../compiler';
+import { ComponentRegistry } from '../registry';
+import { ComponentSpec } from '../registry/component-resolver';
+export interface HierarchyRegistrationResult {
+    success: boolean;
+    registeredComponents: string[];
+    errors: ComponentRegistrationError[];
+    warnings: string[];
+}
+export interface ComponentRegistrationError {
+    componentName: string;
+    error: string;
+    phase: 'compilation' | 'registration' | 'validation';
+}
+export interface HierarchyRegistrationOptions {
+    styles?: ComponentStyles;
+    namespace?: string;
+    version?: string;
+    continueOnError?: boolean;
+    allowOverride?: boolean;
+}
+export declare class ComponentHierarchyRegistrar {
+    private compiler;
+    private registry;
+    private runtimeContext;
+    constructor(compiler: ComponentCompiler, registry: ComponentRegistry, runtimeContext: RuntimeContext);
+    registerHierarchy(rootSpec: ComponentSpec, options?: HierarchyRegistrationOptions): Promise<HierarchyRegistrationResult>;
+    registerSingleComponent(spec: ComponentSpec, options: {
+        styles?: ComponentStyles;
+        namespace?: string;
+        version?: string;
+        allowOverride?: boolean;
+    }): Promise<{
+        success: boolean;
+        error?: ComponentRegistrationError;
+    }>;
+    private registerChildComponents;
+}
+export declare function registerComponentHierarchy(rootSpec: ComponentSpec, compiler: ComponentCompiler, registry: ComponentRegistry, runtimeContext: RuntimeContext, options?: HierarchyRegistrationOptions): Promise<HierarchyRegistrationResult>;
+export declare function validateComponentSpec(spec: ComponentSpec): string[];
+export declare function flattenComponentHierarchy(rootSpec: ComponentSpec): ComponentSpec[];
+export declare function countComponentsInHierarchy(rootSpec: ComponentSpec, includeEmpty?: boolean): number;
+//# sourceMappingURL=component-hierarchy.d.ts.map

package/dist/runtime/component-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-hierarchy.d.ts","sourceRoot":"","sources":["../../src/runtime/component-hierarchy.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,eAAe,EACf,cAAc,EACf,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAK/D,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,MAAM,EAAE,0BAA0B,EAAE,CAAC;IACrC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAKD,MAAM,WAAW,0BAA0B;IACzC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,aAAa,GAAG,cAAc,GAAG,YAAY,CAAC;CACtD;AAKD,MAAM,WAAW,4BAA4B;IAE3C,MAAM,CAAC,EAAE,eAAe,CAAC;IAEzB,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAKD,qBAAa,2BAA2B;IAEpC,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,cAAc;gBAFd,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,cAAc;IASlC,iBAAiB,CACrB,QAAQ,EAAE,aAAa,EACvB,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,2BAA2B,CAAC;IAsDjC,uBAAuB,CAC3B,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE;QACP,MAAM,CAAC,EAAE,eAAe,CAAC;QACzB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,aAAa,CAAC,EAAE,OAAO,CAAC;KACzB,GACA,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,0BAA0B,CAAA;KAAE,CAAC;YA8EtD,uBAAuB;CAwCtC;AAWD,wBAAsB,0BAA0B,CAC9C,QAAQ,EAAE,aAAa,EACvB,QAAQ,EAAE,iBAAiB,EAC3B,QAAQ,EAAE,iBAAiB,EAC3B,cAAc,EAAE,cAAc,EAC9B,OAAO,GAAE,4BAAiC,GACzC,OAAO,CAAC,2BAA2B,CAAC,CAGtC;AAOD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,EAAE,CA2BnE;AAOD,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,EAAE,CASlF;AAQD,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,aAAa,EACvB,YAAY,GAAE,OAAe,GAC5B,MAAM,CAaR"}