ngx-blocks-studio 0.0.1 → 0.0.3

package/fesm2022/ngx-blocks-studio.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { inject, signal, computed, Injectable, Injector, effect, ViewContainerRef, DestroyRef, input, Directive } from '@angular/core';
+import { inject, signal, computed, Injectable, isSignal, Injector, effect, ViewContainerRef, DestroyRef, input, Directive } from '@angular/core';
 import { Router } from '@angular/router';
 import { HttpClient } from '@angular/common/http';
 import { firstValueFrom } from 'rxjs';
@@ -641,6 +641,43 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImpor
                 }]
         }] });
 
+/**
+ * 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);
+    }
+}
+
 /**
  * Service entry: root-scoped (string id) or self-scoped ({ id, scope: "self" }).
  */
@@ -649,6 +686,7 @@ const ServiceEntrySchema = z.union([
     z.object({
         id: z.string().min(1),
         scope: z.literal('self'),
+        alias: z.string().min(1).optional(),
     }),
 ]);
 /**
@@ -659,26 +697,29 @@ const OutputReferenceSchema = 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(),
-    then: z.array(z.object({
+    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({
+    }))
+        .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({
+    })
+        .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(),
+    })
+        .optional(),
 });
-const OutputValueSchema = z.union([
-    z.record(z.string(), z.unknown()),
-    OutputReferenceSchema,
-]);
+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.
@@ -686,10 +727,10 @@ const OutputValueSchema = z.union([
 const BlockDescriptionSchema = z.object({
     component: z.string().min(1),
     id: z.string().min(1).optional(),
-    services: z.union([
-        ServiceEntrySchema,
-        z.array(ServiceEntrySchema),
-    ]).optional().default([]),
+    services: z
+        .union([ServiceEntrySchema, z.array(ServiceEntrySchema)])
+        .optional()
+        .default([]),
     inputs: z.record(z.string(), z.unknown()).optional(),
     outputs: z.record(z.string(), OutputValueSchema).optional(),
 });
@@ -699,9 +740,6 @@ function normalizeServices(services) {
         return [];
     return Array.isArray(services) ? services : [services];
 }
-function parseBlockDescription(data) {
-    return BlockDescriptionSchema.parse(data);
-}
 function safeParseBlockDescription(data) {
     return BlockDescriptionSchema.safeParse(data);
 }
@@ -718,10 +756,6 @@ function isBlockReference(value) {
     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.
@@ -747,60 +781,33 @@ function deepMergeBlockDefinition(base, override) {
     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.
+ * Resolve a block reference to a full description using optional per-call definitions
+ * and the global BlockDefinitionsRegistry. Per-call blockDefinitions take precedence
+ * over global entries. If blockDefinition is present, it is deep-merged onto the base;
+ * otherwise returns a shallow copy of 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];
+    const blockId = ref.blockId;
+    const id = ref.id;
+    const registry = BlockDefinitionsRegistry.getInstance();
+    if (!blockId || typeof blockId !== 'string')
+        throw new Error('Block reference must have blockId.');
+    let base;
+    if (blockDefinitions && Object.prototype.hasOwnProperty.call(blockDefinitions, blockId)) {
+        base = blockDefinitions[blockId];
+    }
+    else {
+        base = registry.get(blockId);
+    }
     if (base == null || typeof base !== 'object')
-        throw new Error(`Block "${id}" has no definition in blockDefinitions.`);
-    const baseObj = base;
+        throw new Error(`Block "${blockId}" has no definition.`);
+    const baseObj = { ...base, id };
     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.
  */
@@ -946,6 +953,34 @@ function resolveRefPath(refPath, ctx) {
     }
     return { target: current, path: rest.slice(-1) };
 }
+/**
+ * Get a value from an object by dot-notation path (e.g. "name.firstName" -> obj.name?.firstName).
+ * Returns undefined if any segment is null/undefined or not an object.
+ */
+function getValueByPath(obj, path) {
+    if (obj == null)
+        return undefined;
+    const parts = path.trim().split('.').filter(Boolean);
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Return true if the value at ref path is an Angular signal (so reading it in an effect would be reactive).
+ */
+function refPathResolvesToSignal(refPath, ctx) {
+    const resolved = resolveRefPath(refPath, ctx);
+    if (resolved == null)
+        return false;
+    const val = resolved.path.length === 0
+        ? resolved.target
+        : resolved.target?.[resolved.path[0]];
+    return val != null && isSignal(val);
+}
 /**
  * Get value at ref path (read-only). Returns undefined if not found.
  */
@@ -958,11 +993,26 @@ function getRefValue(refPath, ctx) {
     const key = resolved.path[0];
     const val = obj?.[key];
     // Unwrap Angular signals and other getter functions by calling them
+    if (val != null && isSignal(val)) {
+        return val();
+    }
     if (typeof val === 'function') {
         return val();
     }
     return val;
 }
+function getRefSignal(refPath, ctx) {
+    const resolved = resolveRefPath(refPath, ctx);
+    if (resolved == null)
+        return undefined;
+    const val = resolved.path.length === 0
+        ? resolved.target
+        : resolved.target?.[resolved.path[0]];
+    if (val != null && isSignal(val)) {
+        return val;
+    }
+    return undefined;
+}
 /**
  * Set value at ref path (write). No-op if target is not writable.
  */
@@ -973,9 +1023,9 @@ function setRefValue(refPath, ctx, value) {
     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'
+        isSignal(val) &&
+        typeof val.set === 'function'
         ? val
         : null;
     if (writable) {
@@ -1074,14 +1124,10 @@ class BlockLoaderService {
     injector = inject(Injector);
     componentRegistry = ComponentRegistry.getInstance();
     serviceRegistry = ServiceRegistry.getInstance();
-    async load(description, viewContainerRef, options) {
+    async load(description, viewContainerRef, model, options) {
         let resolved = description;
         if (isBlockReference(description)) {
-            const definitions = {
-                ...BlockDefinitionsRegistry.getInstance().getAll(),
-                ...(options?.blockDefinitions ?? {}),
-            };
-            resolved = resolveBlockReference(description, definitions);
+            resolved = resolveBlockReference(description, options?.blockDefinitions);
         }
         const parsed = safeParseBlockDescription(resolved);
         if (!parsed.success) {
@@ -1106,26 +1152,25 @@ class BlockLoaderService {
         const blockInstance = {};
         for (let i = 0; i < selfServices.length; i++) {
             const id = selfServices[i].id;
+            const alias = selfServices[i].alias ?? 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);
-                }
+                    blockInstance[alias] = svc;
             }
         }
-        const ctx = { registry, currentBlockId: desc.id ?? undefined, currentInstance: blockInstance };
+        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);
+        this.applyInitialModel(desc, ctx, blockInstance, model);
+        let currentEffectRefs = this.setInputs(componentRef, desc, ctx, model);
+        currentEffectRefs = currentEffectRefs.concat(this.applyModelReactivity(desc, ctx, blockInstance, model));
         const subscriptions = this.wireOutputs(componentRef, desc, registry, options?.outputHandlers);
         const doDestroy = () => {
             if (desc.id != null && desc.id !== '')
@@ -1142,7 +1187,9 @@ class BlockLoaderService {
             const p = safeParseBlockDescription(newDesc);
             if (p.success) {
                 currentEffectRefs.forEach((ref) => ref.destroy());
-                currentEffectRefs = this.setInputs(componentRef, p.data, ctx);
+                this.applyInitialModel(p.data, ctx, blockInstance, model);
+                currentEffectRefs = this.setInputs(componentRef, p.data, ctx, model);
+                currentEffectRefs = currentEffectRefs.concat(this.applyModelReactivity(p.data, ctx, blockInstance, model));
             }
         };
         return { componentRef, destroy: doDestroy, updateInputs };
@@ -1154,17 +1201,22 @@ class BlockLoaderService {
         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 });
+        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) {
+    setInputs(componentRef, desc, ctx, blockModel) {
         const effectRefs = [];
         const inputs = desc.inputs ?? {};
         const inst = componentRef.instance;
         for (const [key, value] of Object.entries(inputs)) {
-            if (key === 'model')
+            if (key === 'model') {
                 continue;
+            }
             if (typeof value === 'string') {
                 const twoWayKind = classifyTwoWayString(value);
                 if (twoWayKind === 'invalid-mix') {
@@ -1174,13 +1226,8 @@ class BlockLoaderService {
                 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') {
+                        if (modelSig != null && isSignal(modelSig)) {
                             effectRefs.push(effect(() => {
                                 const fromRef = getRefValue(refPath, ctx);
                                 if (fromRef === undefined)
@@ -1200,14 +1247,15 @@ class BlockLoaderService {
                 }
             }
             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;
+            if (typeof value === 'string' &&
+                str.indexOf('{{') !== -1 &&
+                str.indexOf('}}', str.indexOf('{{')) !== -1) {
                 effectRefs.push(effect(() => {
-                    const resolved = this.interpolateTemplate(str, ctx);
+                    const modelSig = ctx.currentInstance?.['model'];
+                    const model = modelSig != null && isSignal(modelSig)
+                        ? modelSig()
+                        : modelSig;
+                    const resolved = this.interpolateTemplateMixed(str, ctx, model);
                     if (componentRef.setInput)
                         componentRef.setInput(key, resolved);
                     else
@@ -1223,6 +1271,88 @@ class BlockLoaderService {
         }
         return effectRefs;
     }
+    /** Resolve model from desc (interpolate ref if string) and set on services and blockInstance. */
+    applyInitialModel(desc, ctx, blockInstance, blockModel) {
+        const rawModel = desc.inputs?.['model'];
+        if (rawModel === undefined || rawModel === null) {
+            const model = blockModel();
+            for (const svc of Object.values(blockInstance)) {
+                if (svc != null && typeof svc['setModel'] === 'function') {
+                    svc['setModel'](model);
+                }
+            }
+            blockInstance['model'] = blockModel;
+            return;
+        }
+        let model = rawModel;
+        if (typeof rawModel === 'string') {
+            const refPath = rawModel.trim().replace(/^\{\{\s*|\s*\}\}$/g, '');
+            if (refPath.length > 0) {
+                const refSignal = getRefSignal(refPath, ctx);
+                if (refSignal != null) {
+                    model = refSignal();
+                    blockInstance['model'] = refSignal;
+                }
+                else {
+                    model = getRefValue(refPath, ctx);
+                }
+            }
+        }
+        for (const svc of Object.values(blockInstance)) {
+            if (svc != null && typeof svc['setModel'] === 'function') {
+                svc['setModel'](model);
+            }
+        }
+    }
+    /** If model is a ref string, return an effect that keeps setModel/blockInstance in sync with the ref. */
+    applyModelReactivity(desc, ctx, blockInstance, blockModel) {
+        const rawModel = desc.inputs?.['model'];
+        const refPath = rawModel != null && typeof rawModel === 'string'
+            ? rawModel.trim().replace(/^\{\{\s*|\s*\}\}$/g, '')
+            : '';
+        if (refPath.length === 0) {
+            return [];
+        }
+        const effectRef = effect(() => {
+            const model = refPath ? getRefValue(refPath, ctx) : blockModel();
+            for (const svc of Object.values(blockInstance)) {
+                if (svc != null && typeof svc['setModel'] === 'function') {
+                    svc['setModel'](model);
+                }
+            }
+        }, { ...(ngDevMode ? { debugName: "effectRef" } : {}), injector: this.injector });
+        return [effectRef];
+    }
+    /**
+     * Replace each {{ refPath }} with a value: resolve as ref first (e.g. Person.instance.AuthState.firstName),
+     * else as model path (e.g. firstName, instance.model.firstName). Allows mixing both in one template.
+     */
+    interpolateTemplateMixed(template, ctx, model) {
+        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
+                ? resolveRefPath(ref, ctx) != null
+                    ? getRefValue(ref, ctx)
+                    : getValueByPath(model, ref)
+                : null;
+            parts.push(val != null ? String(val) : '');
+            s = s.slice(end + 2);
+        }
+        return parts.join('');
+    }
     /** Replace all {{ refPath }} with resolved values. Uses parts array + join to avoid N string concats. */
     static INTERPOLATE_MAX_PLACEHOLDERS = 200;
     interpolateTemplate(template, ctx) {
@@ -1287,9 +1417,7 @@ class BlockLoaderService {
             const resolvedPairs = [];
             let changed = false;
             for (const [k, v] of entries) {
-                const childOptions = isNestedBlockDescriptor && k === 'inputs'
-                    ? { preserveTwoWayRefs: true }
-                    : options;
+                const childOptions = isNestedBlockDescriptor && k === 'inputs' ? { preserveTwoWayRefs: true } : options;
                 const resolved = this.resolveInputValue(v, ctx, childOptions);
                 if (resolved !== v)
                     changed = true;
@@ -1311,7 +1439,8 @@ class BlockLoaderService {
         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') {
+            if (emitter != null &&
+                typeof emitter.subscribe === 'function') {
                 const sub = emitter.subscribe((v) => handler(v));
                 subs.push(sub);
             }
@@ -1331,7 +1460,11 @@ 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(',');
+    return arr
+        .map((s) => typeof s === 'string'
+        ? s
+        : `${s.id}:${s.scope ?? ''}`)
+        .join(',');
 }
 class BlockDirective {
     viewContainerRef = inject(ViewContainerRef);
@@ -1345,6 +1478,8 @@ class BlockDirective {
     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" }] : []));
+    /** Model for the block. */
+    model = input(undefined, ...(ngDevMode ? [{ debugName: "model" }] : []));
     loadResult = null;
     loadedComponent = null;
     loadedServicesKey = null;
@@ -1357,8 +1492,6 @@ class BlockDirective {
             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;
@@ -1366,7 +1499,7 @@ class BlockDirective {
                 return;
             }
             const resolved = isBlockReference(desc)
-                ? resolveBlockReference(desc, definitions)
+                ? resolveBlockReference(desc, inputDefs ?? undefined)
                 : desc;
             let data;
             if (resolved === this.lastDescRef && this.lastParsedData != null) {
@@ -1393,10 +1526,10 @@ class BlockDirective {
             const registry = this.blockRegistry() ?? undefined;
             const generation = ++this.loadGeneration;
             this.loader
-                .load(resolved, this.viewContainerRef, {
+                .load(resolved, this.viewContainerRef, this.model, {
                 outputHandlers: Object.keys(outputHandlers).length > 0 ? outputHandlers : undefined,
                 registry,
-                blockDefinitions: definitions ?? undefined,
+                blockDefinitions: inputDefs ?? undefined,
             })
                 .then((result) => {
                 if (generation !== this.loadGeneration)
@@ -1425,7 +1558,7 @@ class BlockDirective {
         }
     }
     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 });
+    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 }, model: { classPropertyName: "model", publicName: "model", 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,
@@ -1433,7 +1566,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImpor
                     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 }] }] } });
+        }], 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 }] }], model: [{ type: i0.Input, args: [{ isSignal: true, alias: "model", required: false }] }] } });
 
 /*
  * Public API Surface of blocks-studio
@@ -1443,5 +1576,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.0", ngImpor
  * 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 };
+export { BlockDefinitionsRegistry, BlockDescriptionSchema, BlockDirective, BlockLoaderService, BlockRegistryImpl, ComponentRegistry, GuardRegistry, RegistryMetadataStore, RouteLoader, ServiceRegistry, buildComputedForTemplate, classifyTwoWayString, createOutputHandler, deepMergeBlockDefinition, extractReadonlyRefs, getRefPathFromReadonly, getRefSignal, getRefValue, getValueByPath, isBlockReference, isInvalidTwoWayMix, isOutputReference, isTwoWayRefString, normalizeServices, parseRefPath, parseTwoWayRef, refPathResolvesToSignal, resolveBlockReference, resolveOutputReference, resolveRefPath, safeParseBlockDescription, setRefValue };
 //# sourceMappingURL=ngx-blocks-studio.mjs.map