ngx-blocks-studio 0.0.1

package/fesm2022/ngx-blocks-studio.mjs

@@ -0,0 +1,1447 @@
+import * as i0 from '@angular/core';
+import { inject, signal, computed, Injectable, Injector, effect, ViewContainerRef, DestroyRef, input, Directive } from '@angular/core';
+import { Router } from '@angular/router';
+import { HttpClient } from '@angular/common/http';
+import { firstValueFrom } from 'rxjs';
+import { z } from 'zod';
+
+/**
+ * Single source of truth for metadata across component, service, and guard registries.
+ * All registries delegate to this store so metadata can be queried uniformly
+ * and all metadata can be retrieved in one call.
+ */
+class RegistryMetadataStore {
+    static instance;
+    entries = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!RegistryMetadataStore.instance) {
+            RegistryMetadataStore.instance = new RegistryMetadataStore();
+        }
+        return RegistryMetadataStore.instance;
+    }
+    /**
+     * Set metadata for a registry key (component, service, or guard).
+     */
+    set(key, type, data) {
+        this.entries.set(key, { type, data });
+    }
+    /**
+     * Get metadata for a key. Returns undefined if the key is not registered.
+     */
+    get(key) {
+        return this.entries.get(key)?.data;
+    }
+    /**
+     * Alias for get(); allows registries to expose getMetadata(key).
+     */
+    getMetadata(key) {
+        return this.get(key);
+    }
+    /**
+     * Get all metadata for a given type (components or services).
+     */
+    getByType(type) {
+        const result = new Map();
+        for (const [key, entry] of this.entries) {
+            if (entry.type === type) {
+                result.set(key, entry.data);
+            }
+        }
+        return result;
+    }
+    /**
+     * Get all metadata for component, service, and guard registries in one call.
+     */
+    getAllMetadata() {
+        return {
+            components: this.getByType('component'),
+            services: this.getByType('service'),
+            guards: this.getByType('guard'),
+        };
+    }
+    /**
+     * Remove metadata for a key (e.g. when unregistering).
+     */
+    remove(key) {
+        return this.entries.delete(key);
+    }
+    /**
+     * Check if metadata exists for a key.
+     */
+    has(key) {
+        return this.entries.has(key);
+    }
+    /**
+     * Clear all metadata (e.g. when clearing registries).
+     */
+    clear() {
+        this.entries.clear();
+    }
+}
+
+class ComponentRegistry {
+    static instance;
+    components = new Map();
+    loadedComponents = new Map();
+    metadataStore = RegistryMetadataStore.getInstance();
+    constructor() { }
+    static getInstance() {
+        if (!ComponentRegistry.instance) {
+            ComponentRegistry.instance = new ComponentRegistry();
+        }
+        return ComponentRegistry.instance;
+    }
+    register(name, component, metadata) {
+        if (this.components.has(name)) {
+            console.warn(`Component ${name} is already registered. Overwriting...`);
+        }
+        this.components.set(name, component);
+        // If it's already a Type, cache it
+        if (typeof component !== 'function' || component.prototype) {
+            this.loadedComponents.set(name, component);
+        }
+        if (metadata != null && Object.keys(metadata).length > 0) {
+            this.metadataStore.set(name, 'component', metadata);
+        }
+    }
+    async get(name) {
+        // Check if already loaded
+        if (this.loadedComponents.has(name)) {
+            return this.loadedComponents.get(name);
+        }
+        const componentOrLoader = this.components.get(name);
+        if (!componentOrLoader) {
+            return undefined;
+        }
+        // Check if it's a loader function (not a Type)
+        // Type functions have a prototype, loader functions don't
+        const isLoader = typeof componentOrLoader === 'function' && !componentOrLoader.prototype?.constructor;
+        if (isLoader) {
+            try {
+                const loader = componentOrLoader;
+                const component = await loader();
+                this.loadedComponents.set(name, component);
+                return component;
+            }
+            catch (error) {
+                console.error(`Failed to lazy load component "${name}":`, error);
+                return undefined;
+            }
+        }
+        // It's already a Type
+        const component = componentOrLoader;
+        this.loadedComponents.set(name, component);
+        return component;
+    }
+    getSync(name) {
+        // Check if already loaded
+        if (this.loadedComponents.has(name)) {
+            return this.loadedComponents.get(name);
+        }
+        const componentOrLoader = this.components.get(name);
+        if (!componentOrLoader) {
+            return undefined;
+        }
+        // Check if it's a loader function (not a Type)
+        const isLoader = typeof componentOrLoader === 'function' && !componentOrLoader.prototype?.constructor;
+        // If it's a loader, we can't get it synchronously
+        if (isLoader) {
+            return undefined;
+        }
+        // It's already a Type
+        const component = componentOrLoader;
+        this.loadedComponents.set(name, component);
+        return component;
+    }
+    has(name) {
+        return this.components.has(name);
+    }
+    getAll() {
+        return new Map(this.loadedComponents);
+    }
+    unregister(name) {
+        this.metadataStore.remove(name);
+        this.loadedComponents.delete(name);
+        return this.components.delete(name);
+    }
+    clear() {
+        for (const name of this.components.keys()) {
+            this.metadataStore.remove(name);
+        }
+        this.components.clear();
+        this.loadedComponents.clear();
+    }
+    getMetadata(key) {
+        return this.metadataStore.getMetadata(key);
+    }
+    getAllWithMetadata() {
+        const result = new Map();
+        for (const [name, component] of this.loadedComponents) {
+            result.set(name, {
+                component,
+                metadata: this.metadataStore.getMetadata(name),
+            });
+        }
+        return result;
+    }
+}
+
+class GuardRegistry {
+    static instance;
+    guards = new Map();
+    loadedGuards = new Map();
+    metadataStore = RegistryMetadataStore.getInstance();
+    constructor() { }
+    static getInstance() {
+        if (!GuardRegistry.instance) {
+            GuardRegistry.instance = new GuardRegistry();
+        }
+        return GuardRegistry.instance;
+    }
+    register(name, guard, metadata) {
+        if (this.guards.has(name)) {
+            console.warn(`Guard "${name}" is already registered. Overwriting...`);
+        }
+        this.guards.set(name, guard);
+        if (!this.isLoader(guard)) {
+            this.loadedGuards.set(name, guard);
+        }
+        else {
+            this.loadedGuards.delete(name);
+        }
+        if (metadata != null && Object.keys(metadata).length > 0) {
+            this.metadataStore.set(name, 'guard', metadata);
+        }
+    }
+    /**
+     * Resolve guard by name (async; runs loader if needed).
+     */
+    async get(name) {
+        if (this.loadedGuards.has(name)) {
+            return this.loadedGuards.get(name);
+        }
+        const guardOrLoader = this.guards.get(name);
+        if (!guardOrLoader) {
+            return undefined;
+        }
+        if (this.isLoader(guardOrLoader)) {
+            try {
+                const loader = guardOrLoader;
+                const guard = await loader();
+                this.loadedGuards.set(name, guard);
+                return guard;
+            }
+            catch (error) {
+                console.error(`Failed to lazy load guard "${name}":`, error);
+                return undefined;
+            }
+        }
+        const guard = guardOrLoader;
+        this.loadedGuards.set(name, guard);
+        return guard;
+    }
+    /**
+     * Resolve guard synchronously. Returns undefined if the entry is a lazy loader not yet loaded.
+     */
+    getSync(name) {
+        if (this.loadedGuards.has(name)) {
+            return this.loadedGuards.get(name);
+        }
+        const guardOrLoader = this.guards.get(name);
+        if (!guardOrLoader || this.isLoader(guardOrLoader)) {
+            return undefined;
+        }
+        const guard = guardOrLoader;
+        this.loadedGuards.set(name, guard);
+        return guard;
+    }
+    has(name) {
+        return this.guards.has(name);
+    }
+    getMetadata(key) {
+        return this.metadataStore.getMetadata(key);
+    }
+    getAllWithMetadata() {
+        const result = new Map();
+        for (const [name, guard] of this.loadedGuards) {
+            result.set(name, {
+                guard,
+                metadata: this.metadataStore.getMetadata(name),
+            });
+        }
+        return result;
+    }
+    unregister(name) {
+        this.metadataStore.remove(name);
+        this.loadedGuards.delete(name);
+        return this.guards.delete(name);
+    }
+    clear() {
+        for (const name of this.guards.keys()) {
+            this.metadataStore.remove(name);
+        }
+        this.guards.clear();
+        this.loadedGuards.clear();
+    }
+    isLoader(value) {
+        return (typeof value === 'function' &&
+            value.length === 0);
+    }
+}
+
+class ServiceRegistry {
+    static instance;
+    services = new Map();
+    loadedServices = new Map();
+    injector = null;
+    metadataStore = RegistryMetadataStore.getInstance();
+    constructor() { }
+    static getInstance() {
+        if (!ServiceRegistry.instance) {
+            ServiceRegistry.instance = new ServiceRegistry();
+        }
+        return ServiceRegistry.instance;
+    }
+    /**
+     * Set the injector to use for service resolution
+     */
+    setInjector(injector) {
+        this.injector = injector;
+    }
+    /**
+     * Register a service by name (supports lazy loading)
+     */
+    register(name, service, metadata) {
+        if (this.services.has(name)) {
+            console.warn(`Service ${name} is already registered. Overwriting...`);
+        }
+        this.services.set(name, service);
+        // If it's already a Type, cache it
+        if (typeof service !== 'function' || service.prototype) {
+            this.loadedServices.set(name, service);
+        }
+        if (metadata != null && Object.keys(metadata).length > 0) {
+            this.metadataStore.set(name, 'service', metadata);
+        }
+    }
+    /**
+     * Get a service instance by name (supports lazy loading)
+     * Requires injector to be set first
+     */
+    async get(name) {
+        // Check if already loaded
+        if (this.loadedServices.has(name)) {
+            const serviceType = this.loadedServices.get(name);
+            return this.injectService(serviceType);
+        }
+        const serviceOrLoader = this.services.get(name);
+        if (!serviceOrLoader) {
+            console.error(`Service "${name}" not found in registry`);
+            return undefined;
+        }
+        // Check if it's a loader function (not a Type)
+        const isLoader = typeof serviceOrLoader === 'function' &&
+            !serviceOrLoader.prototype?.constructor;
+        if (isLoader) {
+            try {
+                const loader = serviceOrLoader;
+                const serviceType = await loader();
+                this.loadedServices.set(name, serviceType);
+                return this.injectService(serviceType);
+            }
+            catch (error) {
+                console.error(`Failed to lazy load service "${name}":`, error);
+                return undefined;
+            }
+        }
+        // It's already a Type
+        const serviceType = serviceOrLoader;
+        this.loadedServices.set(name, serviceType);
+        return this.injectService(serviceType);
+    }
+    /**
+     * Get a service instance synchronously (only works for already loaded services)
+     */
+    getSync(name) {
+        // Check if already loaded
+        if (this.loadedServices.has(name)) {
+            const serviceType = this.loadedServices.get(name);
+            return this.injectService(serviceType);
+        }
+        const serviceOrLoader = this.services.get(name);
+        if (!serviceOrLoader) {
+            console.error(`Service "${name}" not found in registry`);
+            return undefined;
+        }
+        // Check if it's a loader function
+        const isLoader = typeof serviceOrLoader === 'function' &&
+            !serviceOrLoader.prototype?.constructor;
+        // If it's a loader, we can't get it synchronously
+        if (isLoader) {
+            console.warn(`Service "${name}" is lazy loaded and cannot be retrieved synchronously. Use get() instead.`);
+            return undefined;
+        }
+        // It's already a Type
+        const serviceType = serviceOrLoader;
+        this.loadedServices.set(name, serviceType);
+        return this.injectService(serviceType);
+    }
+    /**
+     * Inject a service type using the injector
+     */
+    injectService(serviceType) {
+        if (!this.injector) {
+            // Try to use inject() if no injector is set
+            try {
+                return inject(serviceType);
+            }
+            catch (error) {
+                console.error(`Cannot inject service: No injector set and inject() failed`, error);
+                return undefined;
+            }
+        }
+        try {
+            return this.injector.get(serviceType);
+        }
+        catch (error) {
+            console.error(`Failed to get service from injector:`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Get the service Type (class) by name (supports lazy loading).
+     * Use this to scope the provider to a child injector (e.g. "self" context).
+     */
+    async getType(name) {
+        if (this.loadedServices.has(name)) {
+            return this.loadedServices.get(name);
+        }
+        const serviceOrLoader = this.services.get(name);
+        if (!serviceOrLoader) {
+            console.error(`Service "${name}" not found in registry`);
+            return undefined;
+        }
+        const isLoader = typeof serviceOrLoader === 'function' &&
+            !serviceOrLoader.prototype?.constructor;
+        if (isLoader) {
+            try {
+                const loader = serviceOrLoader;
+                const serviceType = await loader();
+                this.loadedServices.set(name, serviceType);
+                return serviceType;
+            }
+            catch (error) {
+                console.error(`Failed to lazy load service "${name}":`, error);
+                return undefined;
+            }
+        }
+        const serviceType = serviceOrLoader;
+        this.loadedServices.set(name, serviceType);
+        return serviceType;
+    }
+    /**
+     * Get the service Type synchronously (only for already loaded services).
+     */
+    getTypeSync(name) {
+        if (this.loadedServices.has(name)) {
+            return this.loadedServices.get(name);
+        }
+        const serviceOrLoader = this.services.get(name);
+        if (!serviceOrLoader) {
+            return undefined;
+        }
+        const isLoader = typeof serviceOrLoader === 'function' &&
+            !serviceOrLoader.prototype?.constructor;
+        if (isLoader) {
+            return undefined;
+        }
+        const serviceType = serviceOrLoader;
+        this.loadedServices.set(name, serviceType);
+        return serviceType;
+    }
+    /**
+     * Check if a service is registered
+     */
+    has(name) {
+        return this.services.has(name);
+    }
+    /**
+     * Get all registered service names
+     */
+    getAllNames() {
+        return Array.from(this.services.keys());
+    }
+    /**
+     * Get metadata for a registered service by key.
+     */
+    getMetadata(key) {
+        return this.metadataStore.getMetadata(key);
+    }
+    /**
+     * Unregister a service
+     */
+    unregister(name) {
+        this.metadataStore.remove(name);
+        this.loadedServices.delete(name);
+        return this.services.delete(name);
+    }
+    /**
+     * Clear all registered services
+     */
+    clear() {
+        for (const name of this.services.keys()) {
+            this.metadataStore.remove(name);
+        }
+        this.services.clear();
+        this.loadedServices.clear();
+    }
+}
+
+class RouteLoader {
+    router = inject(Router);
+    http = inject(HttpClient);
+    componentRegistry = ComponentRegistry.getInstance();
+    guardRegistry = GuardRegistry.getInstance();
+    _routeConfigFile = signal(null, ...(ngDevMode ? [{ debugName: "_routeConfigFile" }] : []));
+    _configPath = signal('', ...(ngDevMode ? [{ debugName: "_configPath" }] : []));
+    /** Currently loaded route config file, or null if not yet loaded. */
+    routeConfigFile = this._routeConfigFile.asReadonly();
+    /** Path from which the config was loaded. */
+    configPath = this._configPath.asReadonly();
+    /** Route config array from the loaded file. */
+    routeConfig = computed(() => this._routeConfigFile()?.routes ?? [], ...(ngDevMode ? [{ debugName: "routeConfig" }] : []));
+    /**
+     * Load routes from a config object. Updates signals and resets the router.
+     */
+    async loadRoutes(config) {
+        this._configPath.set('');
+        this._routeConfigFile.set(config);
+        await this.updateRoutes();
+    }
+    /**
+     * Fetch route config from a URL (HTTP GET), then load it. Sets configPath signal to the requested URL.
+     */
+    async loadRoutesFromUrl(configPath) {
+        try {
+            const config = await firstValueFrom(this.http.get(configPath));
+            this._configPath.set(configPath);
+            this._routeConfigFile.set(config);
+            await this.updateRoutes();
+        }
+        catch (error) {
+            console.error('Failed to load route configuration from URL:', error);
+            throw error;
+        }
+    }
+    async updateRoutes() {
+        const config = this._routeConfigFile();
+        const routeConfigList = this.routeConfig();
+        const routes = await Promise.all(routeConfigList.map((routeConfig) => this.convertRouteConfig(routeConfig)));
+        if (config?.defaultRedirect != null && config.defaultRedirect !== '') {
+            routes.unshift({
+                path: '',
+                redirectTo: config.defaultRedirect,
+                pathMatch: 'full',
+            });
+        }
+        if (config?.catchAllRedirect != null && config.catchAllRedirect !== '') {
+            routes.push({
+                path: '**',
+                redirectTo: config.catchAllRedirect,
+            });
+        }
+        this.router.resetConfig(routes);
+    }
+    async convertRouteConfig(config) {
+        const routeData = { ...(config.data ?? {}) };
+        if (config.component) {
+            routeData['component'] = config.component;
+        }
+        const [canActivateGuards, canDeactivateGuards, canLoadGuards, canMatchGuards, canActivateChildGuards,] = await Promise.all([
+            this.resolveGuards(config.canActivate),
+            this.resolveGuards(config.canDeactivate),
+            this.resolveGuards(config.canLoad),
+            this.resolveGuards(config.canMatch),
+            this.resolveGuards(config.canActivateChild),
+        ]);
+        const route = {
+            path: config.path,
+            loadComponent: () => this.loadComponent(config),
+            data: routeData,
+            ...(config.title != null && { title: config.title }),
+            ...(config.outlet != null && { outlet: config.outlet }),
+            ...(config.pathMatch != null && { pathMatch: config.pathMatch }),
+            ...(config.runGuardsAndResolvers != null && {
+                runGuardsAndResolvers: config.runGuardsAndResolvers,
+            }),
+            ...(canActivateGuards.length > 0 && {
+                canActivate: canActivateGuards,
+            }),
+            ...(canDeactivateGuards.length > 0 && {
+                canDeactivate: canDeactivateGuards,
+            }),
+            ...(canLoadGuards.length > 0 && { canLoad: canLoadGuards }),
+            ...(canMatchGuards.length > 0 && { canMatch: canMatchGuards }),
+            ...(canActivateChildGuards.length > 0 && {
+                canActivateChild: canActivateChildGuards,
+            }),
+        };
+        if (config.children?.routes?.length) {
+            const childConfigs = config.children;
+            route.children = await Promise.all(childConfigs.routes.map((child) => this.convertRouteConfig(child)));
+            if (childConfigs.defaultRedirect != null && childConfigs.defaultRedirect !== '') {
+                route.children.unshift({
+                    path: '',
+                    redirectTo: childConfigs.defaultRedirect,
+                    pathMatch: 'full',
+                });
+            }
+            if (childConfigs.catchAllRedirect != null && childConfigs.catchAllRedirect !== '') {
+                route.children.push({
+                    path: '**',
+                    redirectTo: childConfigs.catchAllRedirect,
+                });
+            }
+        }
+        return route;
+    }
+    async resolveGuards(guardNames) {
+        if (!guardNames?.length)
+            return [];
+        const resolved = await Promise.all(guardNames.map((name) => this.getGuard(name)));
+        return resolved.filter((g) => g != null);
+    }
+    async loadComponent(routeConfig) {
+        const componentName = routeConfig.component;
+        if (!componentName) {
+            throw new Error('Route config must specify a component key.');
+        }
+        const component = await this.componentRegistry.get(componentName);
+        if (!component) {
+            throw new Error(`Component "${componentName}" is not registered. Register it with ComponentRegistry before loading routes.`);
+        }
+        return component;
+    }
+    async getGuard(guardName) {
+        const guard = await this.guardRegistry.get(guardName);
+        if (guard == null) {
+            console.warn(`Unknown guard: ${guardName}. Register it with GuardRegistry.`);
+            return null;
+        }
+        return guard;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: RouteLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: RouteLoader, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: RouteLoader, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Service entry: root-scoped (string id) or self-scoped ({ id, scope: "self" }).
+ */
+const ServiceEntrySchema = z.union([
+    z.string().min(1),
+    z.object({
+        id: z.string().min(1),
+        scope: z.literal('self'),
+    }),
+]);
+/**
+ * Output handler: empty (use directive-provided handler) or reference-based (call method on ref).
+ */
+const OutputReferenceSchema = z.object({
+    type: z.literal('reference'),
+    reference: z.string().min(1),
+    method: z.string().min(1),
+    params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
+    then: z.array(z.object({
+        reference: z.string().min(1),
+        method: z.string().min(1),
+        params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
+    })).optional(),
+    onSuccess: z.object({
+        reference: z.string().min(1),
+        method: z.string().min(1),
+        params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
+    }).optional(),
+    onError: z.object({
+        reference: z.string().min(1),
+        method: z.string().min(1),
+        params: z.union([z.array(z.unknown()), z.record(z.string(), z.unknown())]).optional(),
+    }).optional(),
+});
+const OutputValueSchema = z.union([
+    z.record(z.string(), z.unknown()),
+    OutputReferenceSchema,
+]);
+/**
+ * Block description: JSON-serializable descriptor for dynamic block loading.
+ * Refs in inputs use instance namespace: instance.FormState.firstName or UserForm.instance.FormState.firstName.
+ */
+const BlockDescriptionSchema = z.object({
+    component: z.string().min(1),
+    id: z.string().min(1).optional(),
+    services: z.union([
+        ServiceEntrySchema,
+        z.array(ServiceEntrySchema),
+    ]).optional().default([]),
+    inputs: z.record(z.string(), z.unknown()).optional(),
+    outputs: z.record(z.string(), OutputValueSchema).optional(),
+});
+/** Normalize services to array. */
+function normalizeServices(services) {
+    if (services == null)
+        return [];
+    return Array.isArray(services) ? services : [services];
+}
+function parseBlockDescription(data) {
+    return BlockDescriptionSchema.parse(data);
+}
+function safeParseBlockDescription(data) {
+    return BlockDescriptionSchema.safeParse(data);
+}
+function isOutputReference(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.type === 'reference' &&
+        typeof value.reference === 'string' &&
+        typeof value.method === 'string');
+}
+function isBlockReference(value) {
+    if (typeof value !== 'object' || value === null || 'component' in value)
+        return false;
+    const id = value.id ?? value.blockId;
+    return typeof id === 'string' && id.length > 0;
+}
+/** @deprecated Use isBlockReference. Id-only is still supported as { id: string }. */
+function isIdReference(value) {
+    return isBlockReference(value) && !value.blockDefinition;
+}
+/**
+ * Deep-merge override onto base. Only keys present in override are changed; nested objects
+ * are merged recursively so e.g. override.inputs.model does not remove base.inputs.rows.
+ * Arrays and primitives in override replace the base value.
+ */
+function deepMergeBlockDefinition(base, override) {
+    const result = { ...base };
+    for (const key of Object.keys(override)) {
+        const baseVal = result[key];
+        const overrideVal = override[key];
+        if (overrideVal != null &&
+            typeof overrideVal === 'object' &&
+            !Array.isArray(overrideVal) &&
+            baseVal != null &&
+            typeof baseVal === 'object' &&
+            !Array.isArray(baseVal)) {
+            result[key] = deepMergeBlockDefinition(baseVal, overrideVal);
+        }
+        else {
+            result[key] = overrideVal;
+        }
+    }
+    return result;
+}
+/**
+ * Resolve a block reference to a full description using blockDefinitions.
+ * If blockDefinition is present, it is deep-merged onto the base; otherwise returns the base.
+ */
+function resolveBlockReference(ref, blockDefinitions) {
+    const id = ref.blockId ?? ref.id;
+    if (!id)
+        throw new Error('Block reference must have id or blockId.');
+    const base = blockDefinitions[id];
+    if (base == null || typeof base !== 'object')
+        throw new Error(`Block "${id}" has no definition in blockDefinitions.`);
+    const baseObj = base;
+    const overrides = ref.blockDefinition;
+    if (overrides == null || typeof overrides !== 'object' || Object.keys(overrides).length === 0)
+        return { ...baseObj };
+    return deepMergeBlockDefinition(baseObj, overrides);
+}
+
+/**
+ * Global registry of block id → definition. Register block configs at app init
+ * so they can be used as templates anywhere (e.g. nested blocks that reference
+ * { id: 'AppNav' } resolve without passing blockDefinitions down).
+ * Per-call blockDefinitions (e.g. from route data) override global entries.
+ */
+class BlockDefinitionsRegistry {
+    static instance;
+    definitions = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!BlockDefinitionsRegistry.instance) {
+            BlockDefinitionsRegistry.instance = new BlockDefinitionsRegistry();
+        }
+        return BlockDefinitionsRegistry.instance;
+    }
+    /** Register a block template by id. Can be called before the block is needed. */
+    register(id, definition) {
+        this.definitions.set(id, definition);
+    }
+    /** Get one definition by id. */
+    get(id) {
+        return this.definitions.get(id);
+    }
+    /** Get all registered definitions (id → definition). Used to merge with per-call definitions. */
+    getAll() {
+        const out = {};
+        this.definitions.forEach((def, id) => {
+            out[id] = def;
+        });
+        return out;
+    }
+    unregister(id) {
+        return this.definitions.delete(id);
+    }
+}
+
+/**
+ * Default in-memory BlockRegistry.
+ */
+class BlockRegistryImpl {
+    map = new Map();
+    register(id, handle) {
+        if (this.map.has(id)) {
+            throw new Error(`Block id "${id}" is already registered. Each id may only occur once per tree.`);
+        }
+        this.map.set(id, handle);
+    }
+    unregister(id) {
+        this.map.delete(id);
+    }
+    get(id) {
+        return this.map.get(id);
+    }
+    has(id) {
+        return this.map.has(id);
+    }
+}
+
+/**
+ * Parse ref paths and detect {{ref}} (read-only) and [(ref)] (two-way) in strings.
+ */
+const READONLY_REF_RE = /\{\{([^}]+)\}\}/g;
+const TWOWAY_REF_RE = /^\[\(([^)]+)\)\]$/;
+const PARSE_REF_PATH_CACHE_MAX = 64;
+const parseRefPathCache = new Map();
+function toPathParts(instancePath) {
+    return instancePath.split('.').filter(Boolean);
+}
+function parseRefPathUncached(refPath) {
+    const trimmed = refPath.trim();
+    const parts = trimmed.split('.');
+    if (parts.length >= 2 && parts[0] === 'instance') {
+        return { instancePath: trimmed, pathParts: toPathParts(trimmed) };
+    }
+    if (parts.length >= 3 && parts[1] === 'instance') {
+        const instancePath = parts.slice(1).join('.');
+        return { blockId: parts[0], instancePath, pathParts: toPathParts(instancePath) };
+    }
+    return { instancePath: trimmed, pathParts: toPathParts(trimmed) };
+}
+function parseRefPath(refPath) {
+    const cached = parseRefPathCache.get(refPath);
+    if (cached)
+        return cached;
+    const result = parseRefPathUncached(refPath);
+    if (parseRefPathCache.size >= PARSE_REF_PATH_CACHE_MAX)
+        parseRefPathCache.clear();
+    parseRefPathCache.set(refPath, result);
+    return result;
+}
+function extractReadonlyRefs(template) {
+    const refs = [];
+    let m;
+    READONLY_REF_RE.lastIndex = 0;
+    while ((m = READONLY_REF_RE.exec(template)) !== null) {
+        const ref = m[1].trim();
+        if (ref && !refs.includes(ref))
+            refs.push(ref);
+    }
+    return refs;
+}
+function isTwoWayRefString(value) {
+    if (typeof value !== 'string')
+        return false;
+    return TWOWAY_REF_RE.test(value.trim());
+}
+/**
+ * True when a string contains two-way ref delimiters `[(` or `)]` but is not a valid
+ * standalone two-way ref (exact form `[(refPath)]`). Mixing two-way with literals or {{ }} is invalid.
+ */
+function isInvalidTwoWayMix(value) {
+    if (typeof value !== 'string')
+        return false;
+    const s = value.trim();
+    const hasDelimiters = s.includes('[(') || s.includes(')]');
+    return hasDelimiters && !TWOWAY_REF_RE.test(s);
+}
+/**
+ * One trim + one pass: classify string for two-way ref handling. Use instead of calling
+ * isInvalidTwoWayMix and isTwoWayRefString separately to avoid double trim/regex.
+ */
+function classifyTwoWayString(value) {
+    if (typeof value !== 'string')
+        return 'none';
+    const s = value.trim();
+    if (!s.includes('[(') && !s.includes(')]'))
+        return 'none';
+    return TWOWAY_REF_RE.test(s) ? 'two-way' : 'invalid-mix';
+}
+function parseTwoWayRef(value) {
+    const m = value.trim().match(TWOWAY_REF_RE);
+    return m ? m[1].trim() : null;
+}
+function getRefPathFromReadonly(template, match) {
+    const re = new RegExp(`\\{\\{${escapeRe(match)}\\}\\}`, 'g');
+    const m = re.exec(template);
+    return m ? match : '';
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Resolve a ref path to the target object and path.
+ * Path format: "instance.FormState.firstName" (context) or "UserForm.instance.FormState.firstName" (registry).
+ */
+function resolveRefPath(refPath, ctx) {
+    const { blockId, pathParts } = parseRefPath(refPath);
+    if (pathParts[0] !== 'instance' || pathParts.length < 2) {
+        return null;
+    }
+    const rest = pathParts.slice(2);
+    const serviceOrProp = pathParts[1];
+    let instance;
+    if (blockId != null) {
+        // Prefer current block's instance when ref points to this block (e.g. root resolving nested refs to itself)
+        if (blockId === ctx.currentBlockId && ctx.currentInstance != null) {
+            instance = ctx.currentInstance;
+        }
+        else {
+            const handle = ctx.registry.get(blockId);
+            instance = handle?.instance;
+        }
+    }
+    else if (ctx.currentInstance != null) {
+        instance = ctx.currentInstance;
+    }
+    if (instance == null)
+        return null;
+    const service = instance[serviceOrProp];
+    if (rest.length === 0) {
+        return { target: service, path: [] };
+    }
+    let current = service;
+    for (let i = 0; i < rest.length - 1; i++) {
+        if (current == null || typeof current !== 'object')
+            return null;
+        current = current[rest[i]];
+    }
+    return { target: current, path: rest.slice(-1) };
+}
+/**
+ * Get value at ref path (read-only). Returns undefined if not found.
+ */
+function getRefValue(refPath, ctx) {
+    const resolved = resolveRefPath(refPath, ctx);
+    if (resolved == null || resolved.path.length === 0) {
+        return resolved?.target;
+    }
+    const obj = resolved.target;
+    const key = resolved.path[0];
+    const val = obj?.[key];
+    // Unwrap Angular signals and other getter functions by calling them
+    if (typeof val === 'function') {
+        return val();
+    }
+    return val;
+}
+/**
+ * Set value at ref path (write). No-op if target is not writable.
+ */
+function setRefValue(refPath, ctx, value) {
+    const resolved = resolveRefPath(refPath, ctx);
+    if (resolved == null || resolved.path.length === 0)
+        return;
+    const obj = resolved.target;
+    const key = resolved.path[0];
+    const val = obj?.[key];
+    // Angular signals are callable (typeof 'function') but have .set; treat any value with .set as writable so we don't overwrite the signal with a string
+    const writable = val != null &&
+        typeof val['set'] === 'function'
+        ? val
+        : null;
+    if (writable) {
+        writable.set(value);
+    }
+    else if (obj != null && typeof obj === 'object') {
+        obj[key] = value;
+    }
+}
+/**
+ * Build a computed signal for a template string with {{refPath}} placeholders.
+ */
+function buildComputedForTemplate(template, refPaths, ctx) {
+    const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return computed(() => {
+        let out = template;
+        for (const refPath of refPaths) {
+            const val = getRefValue(refPath, ctx);
+            const str = val != null ? String(val) : '';
+            out = out.replace(new RegExp(`\\{\\{${escapeRe(refPath)}\\}\\}`, 'g'), str);
+        }
+        return out;
+    });
+}
+
+function getCallTarget(reference, registry) {
+    const resolved = resolveRefPath(reference, { registry });
+    if (resolved == null)
+        return undefined;
+    const { target, path } = resolved;
+    if (path.length === 0)
+        return target;
+    const parent = target;
+    return parent?.[path[0]];
+}
+function getMethodOnTarget(target, methodName) {
+    if (target == null)
+        return null;
+    const m = target[methodName];
+    return typeof m === 'function' ? m : null;
+}
+function resolveOutputReference(ref, eventValue, registry) {
+    return (value) => {
+        const payload = value ?? eventValue;
+        const callTarget = getCallTarget(ref.reference, registry);
+        const method = getMethodOnTarget(callTarget, ref.method);
+        if (method == null)
+            return;
+        const params = ref.params != null
+            ? (Array.isArray(ref.params) ? ref.params : [ref.params])
+            : [payload];
+        const result = method.call(callTarget, ...params);
+        if (result != null && typeof result.then === 'function') {
+            result.then(() => runThenOrSuccess(ref, registry), () => runOnError(ref, registry));
+        }
+        else {
+            runThenOrSuccess(ref, registry);
+        }
+    };
+}
+function toParams(p) {
+    if (p == null)
+        return [];
+    return Array.isArray(p) ? p : [p];
+}
+function runThenOrSuccess(ref, registry) {
+    if (ref.then?.length) {
+        for (const step of ref.then) {
+            invokeRefMethod(registry, step.reference, step.method, toParams(step.params));
+        }
+    }
+    else if (ref.onSuccess) {
+        invokeRefMethod(registry, ref.onSuccess.reference, ref.onSuccess.method, toParams(ref.onSuccess.params));
+    }
+}
+function runOnError(ref, registry) {
+    if (ref.onError) {
+        invokeRefMethod(registry, ref.onError.reference, ref.onError.method, toParams(ref.onError.params));
+    }
+}
+function invokeRefMethod(registry, reference, method, params) {
+    const callTarget = getCallTarget(reference, registry);
+    const fn = getMethodOnTarget(callTarget, method);
+    if (fn)
+        fn.call(callTarget, ...params);
+}
+function createOutputHandler(outputValue, outputKey, registry, directiveHandlers) {
+    if (isOutputReference(outputValue)) {
+        return resolveOutputReference(outputValue, undefined, registry);
+    }
+    const fromDirective = directiveHandlers?.[outputKey];
+    return fromDirective ?? (() => { });
+}
+
+class BlockLoaderService {
+    injector = inject(Injector);
+    componentRegistry = ComponentRegistry.getInstance();
+    serviceRegistry = ServiceRegistry.getInstance();
+    async load(description, viewContainerRef, options) {
+        let resolved = description;
+        if (isBlockReference(description)) {
+            const definitions = {
+                ...BlockDefinitionsRegistry.getInstance().getAll(),
+                ...(options?.blockDefinitions ?? {}),
+            };
+            resolved = resolveBlockReference(description, definitions);
+        }
+        const parsed = safeParseBlockDescription(resolved);
+        if (!parsed.success) {
+            throw new Error(`Invalid block description: ${parsed.error.message}`);
+        }
+        const desc = parsed.data;
+        const registry = options?.registry ?? new BlockRegistryImpl();
+        if (desc.id != null && desc.id !== '' && registry.has(desc.id)) {
+            throw new Error(`Block id "${desc.id}" is already registered.`);
+        }
+        const componentType = await this.componentRegistry.get(desc.component);
+        if (!componentType) {
+            throw new Error(`Component "${desc.component}" is not registered.`);
+        }
+        const services = normalizeServices(desc.services);
+        const selfServices = services.filter((s) => typeof s === 'object' && s.scope === 'self');
+        const serviceTypes = await this.getServiceTypes(selfServices);
+        const childInjector = this.buildChildInjectorFromTypes(serviceTypes);
+        const componentRef = viewContainerRef.createComponent(componentType, {
+            injector: childInjector,
+        });
+        const blockInstance = {};
+        for (let i = 0; i < selfServices.length; i++) {
+            const id = selfServices[i].id;
+            const serviceType = serviceTypes[i];
+            if (serviceType) {
+                const svc = componentRef.injector.get(serviceType);
+                if (svc != null)
+                    blockInstance[id] = svc;
+            }
+        }
+        if (desc.inputs?.['model'] != null) {
+            const model = desc.inputs['model'];
+            for (const svc of Object.values(blockInstance)) {
+                if (svc != null && typeof svc['setModel'] === 'function') {
+                    svc['setModel'](model);
+                }
+            }
+        }
+        const ctx = { registry, currentBlockId: desc.id ?? undefined, currentInstance: blockInstance };
+        const handle = { instance: blockInstance };
+        if (desc.id != null && desc.id !== '')
+            registry.register(desc.id, handle);
+        let currentEffectRefs = this.setInputs(componentRef, desc, ctx);
+        const subscriptions = this.wireOutputs(componentRef, desc, registry, options?.outputHandlers);
+        const doDestroy = () => {
+            if (desc.id != null && desc.id !== '')
+                registry.unregister(desc.id);
+            currentEffectRefs.forEach((ref) => ref.destroy());
+            subscriptions.forEach((s) => s.unsubscribe());
+            const idx = viewContainerRef.indexOf(componentRef.hostView);
+            if (idx !== -1)
+                viewContainerRef.remove(idx);
+            componentRef.destroy();
+        };
+        handle.destroy = doDestroy;
+        const updateInputs = (newDesc) => {
+            const p = safeParseBlockDescription(newDesc);
+            if (p.success) {
+                currentEffectRefs.forEach((ref) => ref.destroy());
+                currentEffectRefs = this.setInputs(componentRef, p.data, ctx);
+            }
+        };
+        return { componentRef, destroy: doDestroy, updateInputs };
+    }
+    /** Resolve all service types in parallel (single batch for load). */
+    async getServiceTypes(selfServices) {
+        if (selfServices.length === 0)
+            return [];
+        return Promise.all(selfServices.map((e) => this.serviceRegistry.getType(e.id)));
+    }
+    buildChildInjectorFromTypes(serviceTypes) {
+        const providers = serviceTypes.filter((t) => t != null).map((t) => ({ provide: t, useClass: t }));
+        return providers.length === 0 ? this.injector : Injector.create({ providers, parent: this.injector });
+    }
+    /** Set inputs and wire template/two-way effects. Single pass over inputs for large configs. */
+    setInputs(componentRef, desc, ctx) {
+        const effectRefs = [];
+        const inputs = desc.inputs ?? {};
+        const inst = componentRef.instance;
+        for (const [key, value] of Object.entries(inputs)) {
+            if (key === 'model')
+                continue;
+            if (typeof value === 'string') {
+                const twoWayKind = classifyTwoWayString(value);
+                if (twoWayKind === 'invalid-mix') {
+                    throw new Error(`Invalid input "${String(key)}": two-way ref "[( )]" cannot be mixed with literals or "{{ }}". ` +
+                        `Use exactly "[(refPath)]" for two-way or "{{ refPath }}" for read-only.`);
+                }
+                if (twoWayKind === 'two-way') {
+                    const refPath = parseTwoWayRef(value);
+                    if (refPath) {
+                        const initial = getRefValue(refPath, ctx);
+                        if (componentRef.setInput)
+                            componentRef.setInput(key, initial);
+                        else
+                            inst[key] = initial;
+                        const modelSig = inst[key];
+                        if (modelSig != null && typeof modelSig === 'function') {
+                            effectRefs.push(effect(() => {
+                                const fromRef = getRefValue(refPath, ctx);
+                                if (fromRef === undefined)
+                                    return;
+                                if (componentRef.setInput) {
+                                    componentRef.setInput(key, fromRef);
+                                    componentRef.changeDetectorRef.detectChanges();
+                                }
+                            }, { injector: this.injector }));
+                            effectRefs.push(effect(() => {
+                                const current = modelSig();
+                                setRefValue(refPath, ctx, current);
+                            }, { injector: this.injector }));
+                        }
+                    }
+                    continue;
+                }
+            }
+            const str = value;
+            if (typeof value === 'string' && str.indexOf('{{') !== -1 && str.indexOf('}}', str.indexOf('{{')) !== -1) {
+                const initial = this.interpolateTemplate(str, ctx);
+                if (componentRef.setInput)
+                    componentRef.setInput(key, initial);
+                else
+                    inst[key] = initial;
+                effectRefs.push(effect(() => {
+                    const resolved = this.interpolateTemplate(str, ctx);
+                    if (componentRef.setInput)
+                        componentRef.setInput(key, resolved);
+                    else
+                        inst[key] = resolved;
+                }, { injector: this.injector }));
+                continue;
+            }
+            const resolved = this.resolveInputValue(value, ctx);
+            if (componentRef.setInput)
+                componentRef.setInput(key, resolved);
+            else
+                inst[key] = resolved;
+        }
+        return effectRefs;
+    }
+    /** Replace all {{ refPath }} with resolved values. Uses parts array + join to avoid N string concats. */
+    static INTERPOLATE_MAX_PLACEHOLDERS = 200;
+    interpolateTemplate(template, ctx) {
+        const parts = [];
+        let s = template;
+        for (let i = 0; i < BlockLoaderService.INTERPOLATE_MAX_PLACEHOLDERS; i++) {
+            const start = s.indexOf('{{');
+            if (start === -1) {
+                parts.push(s);
+                break;
+            }
+            parts.push(s.slice(0, start));
+            const end = s.indexOf('}}', start);
+            if (end === -1) {
+                parts.push(s.slice(start));
+                break;
+            }
+            const ref = s.slice(start + 2, end).trim();
+            const val = ref ? getRefValue(ref, ctx) : null;
+            parts.push(val != null ? String(val) : '');
+            s = s.slice(end + 2);
+        }
+        return parts.join('');
+    }
+    /**
+     * Resolve a single input value: resolve two-way refs, recurse into arrays/objects.
+     * Strings with {{ }} are left as-is so child blocks receive the template for reactive interpolation.
+     * Two-way refs inside nested block descriptors (object with "component" + "inputs") are left as-is
+     * so that when a child block is loaded it still sees value: '[(ref)]' and can wire two-way binding.
+     */
+    resolveInputValue(value, ctx, options) {
+        const preserveTwoWayRefs = options?.preserveTwoWayRefs ?? false;
+        if (typeof value === 'string') {
+            const twoWayKind = classifyTwoWayString(value);
+            if (twoWayKind === 'invalid-mix') {
+                const preview = value.length > 200 ? `${value.slice(0, 200)}...` : value;
+                throw new Error(`Invalid input: two-way ref "[( )]" cannot be mixed with literals or "{{ }}". ` +
+                    `Use exactly "[(refPath)]" for two-way or "{{ refPath }}" for read-only. Got: ${JSON.stringify(preview)}`);
+            }
+            if (twoWayKind === 'two-way') {
+                if (preserveTwoWayRefs)
+                    return value;
+                const refPath = parseTwoWayRef(value);
+                return refPath ? getRefValue(refPath, ctx) : value;
+            }
+            return value;
+        }
+        if (Array.isArray(value)) {
+            let changed = false;
+            const resolved = value.map((item) => {
+                const r = this.resolveInputValue(item, ctx, options);
+                if (r !== item)
+                    changed = true;
+                return r;
+            });
+            return changed ? resolved : value;
+        }
+        if (value != null && typeof value === 'object') {
+            const obj = value;
+            const isNestedBlockDescriptor = typeof obj['component'] === 'string' && obj['inputs'] != null;
+            const entries = Object.entries(value);
+            const resolvedPairs = [];
+            let changed = false;
+            for (const [k, v] of entries) {
+                const childOptions = isNestedBlockDescriptor && k === 'inputs'
+                    ? { preserveTwoWayRefs: true }
+                    : options;
+                const resolved = this.resolveInputValue(v, ctx, childOptions);
+                if (resolved !== v)
+                    changed = true;
+                resolvedPairs.push([k, resolved]);
+            }
+            if (!changed)
+                return value;
+            const out = {};
+            for (const [k, r] of resolvedPairs)
+                out[k] = r;
+            return out;
+        }
+        return value;
+    }
+    wireOutputs(componentRef, desc, registry, outputHandlers) {
+        const subs = [];
+        const outputs = desc.outputs ?? {};
+        const inst = componentRef.instance;
+        for (const [outputKey, outputValue] of Object.entries(outputs)) {
+            const handler = createOutputHandler(outputValue, outputKey, registry, outputHandlers);
+            const emitter = inst[outputKey];
+            if (emitter != null && typeof emitter.subscribe === 'function') {
+                const sub = emitter.subscribe((v) => handler(v));
+                subs.push(sub);
+            }
+        }
+        return subs;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockLoaderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockLoaderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+/** Compact key for services to avoid JSON.stringify of large config in effect. */
+function getServicesKey(services) {
+    const arr = normalizeServices(services);
+    if (arr.length === 0)
+        return '';
+    return arr.map((s) => (typeof s === 'string' ? s : `${s.id}:${s.scope ?? ''}`)).join(',');
+}
+class BlockDirective {
+    viewContainerRef = inject(ViewContainerRef);
+    loader = inject(BlockLoaderService);
+    destroyRef = inject(DestroyRef);
+    /** Full description, or { id } / { blockId, blockDefinition? } to reuse/override from blockDefinitions. */
+    description = input(null, ...(ngDevMode ? [{ debugName: "description" }] : []));
+    /** Handlers for component outputs; keys match descriptor.outputs. */
+    outputHandlers = input({}, ...(ngDevMode ? [{ debugName: "outputHandlers" }] : []));
+    /** Registry for block instances by id; pass from root so nested blocks share it. */
+    blockRegistry = input(null, ...(ngDevMode ? [{ debugName: "blockRegistry" }] : []));
+    /** Map id → full description; used when description is a block reference (id/blockId). */
+    blockDefinitions = input(null, ...(ngDevMode ? [{ debugName: "blockDefinitions" }] : []));
+    loadResult = null;
+    loadedComponent = null;
+    loadedServicesKey = null;
+    loadGeneration = 0;
+    /** Avoid re-parsing when the same description reference is passed (e.g. stable signal). */
+    lastDescRef = null;
+    lastParsedData = null;
+    constructor() {
+        effect(() => {
+            const desc = this.description();
+            const outputHandlers = this.outputHandlers();
+            const inputDefs = this.blockDefinitions();
+            const global = BlockDefinitionsRegistry.getInstance().getAll();
+            const definitions = { ...global, ...(inputDefs ?? {}) };
+            if (desc == null) {
+                this.lastDescRef = null;
+                this.lastParsedData = null;
+                this.clear();
+                return;
+            }
+            const resolved = isBlockReference(desc)
+                ? resolveBlockReference(desc, definitions)
+                : desc;
+            let data;
+            if (resolved === this.lastDescRef && this.lastParsedData != null) {
+                data = this.lastParsedData;
+            }
+            else {
+                const parsed = safeParseBlockDescription(resolved);
+                if (!parsed.success) {
+                    return;
+                }
+                this.lastDescRef = resolved;
+                this.lastParsedData = parsed.data;
+                data = parsed.data;
+            }
+            const servicesKey = getServicesKey(data.services);
+            const canUpdate = this.loadResult != null &&
+                this.loadedComponent === data.component &&
+                this.loadedServicesKey === servicesKey;
+            if (canUpdate && this.loadResult) {
+                this.loadResult.updateInputs(resolved);
+                return;
+            }
+            this.clear();
+            const registry = this.blockRegistry() ?? undefined;
+            const generation = ++this.loadGeneration;
+            this.loader
+                .load(resolved, this.viewContainerRef, {
+                outputHandlers: Object.keys(outputHandlers).length > 0 ? outputHandlers : undefined,
+                registry,
+                blockDefinitions: definitions ?? undefined,
+            })
+                .then((result) => {
+                if (generation !== this.loadGeneration)
+                    return;
+                this.loadResult = result;
+                this.loadedComponent = data.component;
+                this.loadedServicesKey = servicesKey;
+            })
+                .catch((err) => {
+                if (generation !== this.loadGeneration)
+                    return;
+                console.error('Block load failed:', err);
+            });
+        });
+        this.destroyRef.onDestroy(() => this.clear());
+    }
+    clear() {
+        this.loadGeneration++;
+        this.lastDescRef = null;
+        this.lastParsedData = null;
+        if (this.loadResult) {
+            this.loadResult.destroy();
+            this.loadResult = null;
+            this.loadedComponent = null;
+            this.loadedServicesKey = null;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.0", type: BlockDirective, isStandalone: true, selector: "[block]", inputs: { description: { classPropertyName: "description", publicName: "description", isSignal: true, isRequired: false, transformFunction: null }, outputHandlers: { classPropertyName: "outputHandlers", publicName: "outputHandlers", isSignal: true, isRequired: false, transformFunction: null }, blockRegistry: { classPropertyName: "blockRegistry", publicName: "blockRegistry", isSignal: true, isRequired: false, transformFunction: null }, blockDefinitions: { classPropertyName: "blockDefinitions", publicName: "blockDefinitions", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImport: i0, type: BlockDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[block]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { description: [{ type: i0.Input, args: [{ isSignal: true, alias: "description", required: false }] }], outputHandlers: [{ type: i0.Input, args: [{ isSignal: true, alias: "outputHandlers", required: false }] }], blockRegistry: [{ type: i0.Input, args: [{ isSignal: true, alias: "blockRegistry", required: false }] }], blockDefinitions: [{ type: i0.Input, args: [{ isSignal: true, alias: "blockDefinitions", required: false }] }] } });
+
+/*
+ * Public API Surface of blocks-studio
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { BlockDefinitionsRegistry, BlockDescriptionSchema, BlockDirective, BlockLoaderService, BlockRegistryImpl, ComponentRegistry, GuardRegistry, RegistryMetadataStore, RouteLoader, ServiceRegistry, buildComputedForTemplate, classifyTwoWayString, createOutputHandler, deepMergeBlockDefinition, extractReadonlyRefs, getRefPathFromReadonly, getRefValue, isBlockReference, isIdReference, isInvalidTwoWayMix, isOutputReference, isTwoWayRefString, normalizeServices, parseBlockDescription, parseRefPath, parseTwoWayRef, resolveBlockReference, resolveOutputReference, resolveRefPath, safeParseBlockDescription, setRefValue };
+//# sourceMappingURL=ngx-blocks-studio.mjs.map