ngx-blocks-studio 0.1.1 → 0.2.1

package/fesm2022/ngx-blocks-studio.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { inject, signal, computed, Injectable, isSignal, isWritableSignal, linkedSignal, inputBinding, twoWayBinding, outputBinding, Injector, ViewContainerRef, DestroyRef, input, effect, Directive } from '@angular/core';
+import { inject, signal, computed, Injectable, isSignal, reflectComponentType, isWritableSignal, linkedSignal, inputBinding, twoWayBinding, outputBinding, Injector, ViewContainerRef, DestroyRef, input, effect, Directive } from '@angular/core';
 import { Router } from '@angular/router';
 import { HttpClient } from '@angular/common/http';
 import { firstValueFrom } from 'rxjs';
@@ -851,10 +851,10 @@ class RouteLoader {
         }
         return guard;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: RouteLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: RouteLoader, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: RouteLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: RouteLoader, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: RouteLoader, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: RouteLoader, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root',
@@ -938,10 +938,10 @@ class BlockRegistryService {
     getParentScopeKey(scopeKey) {
         return this.registry.get(scopeKey)?.parentScopeKey ?? null;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockRegistryService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockRegistryService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockRegistryService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -1273,15 +1273,15 @@ function isTwoWayRefString(value) {
     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.
+ * True when a string contains the two-way ref opener `[(` but is not a valid standalone
+ * two-way ref (exact form `[(refPath)]`). Mixing two-way with literals or {{ }} is invalid.
+ * Plain `)]` substrings (e.g. Tailwind `minmax(0,1fr)]`) are not treated as two-way syntax.
  */
 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);
+    return s.includes('[(') && !TWOWAY_REF_RE.test(s);
 }
 /**
  * One trim + one pass: classify string for two-way ref handling. Use instead of calling
@@ -1293,15 +1293,8 @@ function classifyTwoWayString(value) {
     const s = value.trim();
     if (TWOWAY_REF_RE.test(s))
         return 'two-way';
-    const hasOpen = s.includes('[(');
-    const hasClose = s.includes(')]');
-    if (!hasOpen && !hasClose)
-        return 'none';
-    // Only treat as invalid mix when the string looks like an attempted two-way ref
-    // wrapper, not when it contains ")]" from normal indexing/calls inside templates.
-    if ((hasOpen && hasClose) || s.startsWith('[(') || s.endsWith(')]')) {
+    if (s.includes('[('))
         return 'invalid-mix';
-    }
     return 'none';
 }
 function parseTwoWayRef(value) {
@@ -1357,7 +1350,9 @@ function resolveRefPath(refPath, ctx) {
             instance = ctx.currentInstance;
         }
         else {
-            const handle = (registry ?? ctx.registry).get(blockId);
+            /* v8 ignore next -- registry is always set when blockId resolves (see scope guard above) */
+            const blockRegistry = registry ?? ctx.registry;
+            const handle = blockRegistry.get(blockId);
             if (!handle) {
                 warnOnce(`Ref "${refPath}" could not resolve block id "${blockId}".`);
                 return null;
@@ -1440,11 +1435,16 @@ function getValueByPath(obj, path) {
  */
 function refPathResolvesToSignal(refPath, ctx) {
     const resolved = resolveRefPath(refPath, ctx);
-    if (resolved == null)
+    if (resolved == null) {
         return false;
-    const val = resolved.path.length === 0
-        ? resolved.target
-        : resolved.target?.[resolved.path[0]];
+    }
+    let val;
+    if (resolved.path.length === 0) {
+        val = resolved.target;
+    }
+    else {
+        val = resolved.target?.[resolved.path[0]];
+    }
     return val != null && isSignal(val);
 }
 /**
@@ -1510,8 +1510,12 @@ function setRefValue(refPath, ctx, value) {
     if (writable) {
         writable.set(value);
     }
-    else if (obj != null && typeof obj === 'object') {
-        obj[key] = value;
+    else {
+        /* v8 ignore start */
+        if (obj != null && typeof obj === 'object') {
+            obj[key] = value;
+        }
+        /* v8 ignore end */
     }
 }
 /**
@@ -1597,12 +1601,12 @@ function parseFlowTemplate(template) {
             let next = bodyEnd + 1;
             let elseBody;
             let cursor = next;
-            while (cursor < template.length && /\s/.test(template[cursor] ?? '')) {
+            while (cursor < template.length && /\s/.test(template[cursor])) {
                 cursor++;
             }
             if (template.startsWith('@else', cursor)) {
                 let elseCursor = cursor + '@else'.length;
-                while (elseCursor < template.length && /\s/.test(template[elseCursor] ?? '')) {
+                while (elseCursor < template.length && /\s/.test(template[elseCursor])) {
                     elseCursor++;
                 }
                 if (template[elseCursor] === '{') {
@@ -1672,7 +1676,7 @@ function parseFlowTemplate(template) {
             i = end;
         }
         else {
-            nodes.push({ type: 'text', value: rest[0] ?? '' });
+            nodes.push({ type: 'text', value: rest.charAt(0) });
             i++;
         }
     }
@@ -1788,6 +1792,7 @@ function interpretFlow(nodes, ctx, scope = {}, options) {
             }
             continue;
         }
+        /* v8 ignore start -- exhaustive node.type chain; non-for nodes handled above */
         if (node.type === 'for') {
             const arr = resolveRefOrModel(node.refPath, ctx);
             const list = Array.isArray(arr) ? arr : [];
@@ -1800,6 +1805,7 @@ function interpretFlow(nodes, ctx, scope = {}, options) {
             }
             continue;
         }
+        /* v8 ignore end */
     }
     return out;
 }
@@ -2104,6 +2110,7 @@ function evalExpr(expr, ctx) {
             if (obj == null || (typeof obj !== 'object' && typeof obj !== 'function'))
                 return undefined;
             const key = evalExpr(expr.index, ctx);
+            /* v8 ignore next */
             if (typeof key !== 'string' && typeof key !== 'number')
                 return undefined;
             return obj[key];
@@ -2129,13 +2136,18 @@ function evalExpr(expr, ctx) {
         }
         case 'unary': {
             const v = evalExpr(expr.argument, ctx);
-            if (expr.op === '!')
+            if (expr.op === '!') {
                 return !v;
-            if (expr.op === '+')
+            }
+            if (expr.op === '+') {
                 return Number(v);
-            if (expr.op === '-')
+            }
+            /* v8 ignore start */
+            if (expr.op === '-') {
                 return -Number(v);
+            }
             return undefined;
+            /* v8 ignore end */
         }
         case 'binary': {
             const left = evalExpr(expr.left, ctx);
@@ -2158,6 +2170,7 @@ function evalExpr(expr, ctx) {
                 case '!=': return left != right;
                 case '===': return left === right;
                 case '!==': return left !== right;
+                /* v8 ignore next */
                 default: return undefined;
             }
         }
@@ -2178,9 +2191,11 @@ function evaluateSafeExpression(expression, resolverContext, payload, resolveRef
 const MUSTACHE_MAX_SEGMENTS = 200;
 function resolveReferenceValue(ref, ctx) {
     const resolved = resolveRefPath(ref, ctx);
-    if (resolved != null)
+    if (resolved != null) {
         return getRefValue(ref, ctx);
-    return getValueByPath(ctx.currentInstance?.model?.() ?? {}, ref);
+    }
+    const model = ctx.currentInstance?.model?.() ?? {};
+    return getValueByPath(model, ref);
 }
 /**
  * Safe expression evaluation (same as output `{{ }}` / `@if (...)` when used with this module).
@@ -2220,7 +2235,7 @@ function resolveMustacheInterpolatedString(value, ctx, payload) {
     let out = '';
     let lastIndex = 0;
     for (const match of limited) {
-        const start = match.index ?? 0;
+        const start = match.index;
         out += value.slice(lastIndex, start);
         const evaluated = evaluateExpression(match[1], ctx, payload);
         out += evaluated != null ? String(evaluated) : '';
@@ -2428,9 +2443,14 @@ function runThenChain(steps, index, ctx, parentDef, payload, onComplete) {
     }
 }
 function runOnError(def, ctx, payload) {
-    if (def.onError && shouldRunWhen(def.onError.when, ctx, payload)) {
-        invokeRefMethod(ctx, def.onError.ref, payload, resolveStepParams(def.onError.params, ctx, payload));
+    const onError = def.onError;
+    if (onError == null) {
+        return;
     }
+    if (!shouldRunWhen(onError.when, ctx, payload)) {
+        return;
+    }
+    invokeRefMethod(ctx, onError.ref, payload, resolveStepParams(onError.params, ctx, payload));
 }
 function invokeRefMethod(ctx, refTemplate, payload, params) {
     const resolvedCallable = resolveReferencePath(refTemplate, ctx, payload);
@@ -2458,6 +2478,147 @@ function createOutputHandler(outputValue, _outputKey, ctx) {
     return () => { };
 }
 
+/** JSON-like objects only — skip class instances, Date, Map, etc. */
+function isPlainObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+function looksLikeBlockIdReference(value) {
+    if (value['component'] != null)
+        return false;
+    const blockId = value['blockId'];
+    if (typeof blockId === 'string' && blockId.length > 0) {
+        return true;
+    }
+    const id = value['id'];
+    if (typeof id !== 'string' || id.length === 0) {
+        return false;
+    }
+    if ('blockDefinition' in value) {
+        return true;
+    }
+    const keys = Object.keys(value);
+    if (keys.length !== 1 || keys[0] !== 'id') {
+        return false;
+    }
+    return !id.includes('{{') && !id.includes('[(');
+}
+/**
+ * Child block entry in a parent input tree (`blocks`, `rows`, `columns`, etc.).
+ * Template refs inside these objects are resolved when that block is loaded, not on the parent.
+ */
+function looksLikeBlockDescriptor(value) {
+    if (!isPlainObject(value))
+        return false;
+    if (typeof value['component'] === 'string' && isPlainObject(value['inputs'])) {
+        return true;
+    }
+    return looksLikeBlockIdReference(value);
+}
+/** Same as {@link looksLikeBlockDescriptor}; use in custom layout blocks if needed. */
+const shouldDeferInputTemplateResolution = looksLikeBlockDescriptor;
+function stringNeedsInputResolve(s) {
+    if (classifyTwoWayString(s) !== 'none')
+        return true;
+    if (s.includes('{{') && s.includes('}}'))
+        return true;
+    if (looksLikeFlowTemplate(s))
+        return true;
+    return false;
+}
+/** True when any string leaf in the tree needs input-style resolution (mustache, flow, or `[( )]`). */
+function valueNeedsInputResolve(value, visited = new WeakSet()) {
+    if (typeof value === 'string') {
+        return stringNeedsInputResolve(value);
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => valueNeedsInputResolve(item, visited));
+    }
+    if (value != null && typeof value === 'object') {
+        if (!isPlainObject(value))
+            return false;
+        if (looksLikeBlockDescriptor(value))
+            return false;
+        if (visited.has(value))
+            return false;
+        visited.add(value);
+        return Object.values(value).some((item) => valueNeedsInputResolve(item, visited));
+    }
+    return false;
+}
+/** True when any string leaf contains `{{ }}` (block model seeding). */
+function valueContainsMustacheInTree(value, visited = new WeakSet()) {
+    if (typeof value === 'string') {
+        return value.includes('{{') && value.includes('}}');
+    }
+    if (Array.isArray(value)) {
+        return value.some((item) => valueContainsMustacheInTree(item, visited));
+    }
+    if (value != null && typeof value === 'object') {
+        if (!isPlainObject(value))
+            return false;
+        if (looksLikeBlockDescriptor(value))
+            return false;
+        if (visited.has(value))
+            return false;
+        visited.add(value);
+        return Object.values(value).some((item) => valueContainsMustacheInTree(item, visited));
+    }
+    return false;
+}
+function resolveStringLeaf(str, ctx, path, options) {
+    const twoWayKind = classifyTwoWayString(str);
+    if (twoWayKind === 'invalid-mix') {
+        throw new Error(`Invalid value at "${path}": two-way ref "[( )]" cannot be mixed with literals or "{{ }}". ` +
+            `Use exactly "[(refPath)]" for read-resolve or "{{ refPath }}" for read-only.`);
+    }
+    if (twoWayKind === 'two-way' && options.resolveTwoWayStringsAsReadonly) {
+        const refPath = parseTwoWayRef(str);
+        if (refPath) {
+            return getRefValue(refPath, ctx);
+        }
+    }
+    return resolveTemplateString(str, ctx, undefined, {
+        escapeFlowRefs: options.escapeFlowRefs !== false,
+    });
+}
+/**
+ * Deep-resolve template strings in plain objects and arrays (new object graph each call).
+ */
+function resolveNestedTemplateValues(value, ctx, path = '', visited = new WeakSet(), options = {}) {
+    if (typeof value === 'string') {
+        return resolveStringLeaf(value, ctx, path || 'input', options);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => {
+            const childPath = path ? `${path}[${index}]` : `[${index}]`;
+            return resolveNestedTemplateValues(item, ctx, childPath, visited, options);
+        });
+    }
+    if (value != null && typeof value === 'object') {
+        if (!isPlainObject(value))
+            return value;
+        if (looksLikeBlockDescriptor(value))
+            return value;
+        if (visited.has(value))
+            return value;
+        visited.add(value);
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+            const childPath = path ? `${path}.${key}` : key;
+            return [key, resolveNestedTemplateValues(item, ctx, childPath, visited, options)];
+        }));
+    }
+    return value;
+}
+
+const NESTED_INPUT_RESOLVE_OPTIONS = {
+    resolveTwoWayStringsAsReadonly: true,
+    escapeFlowRefs: true,
+};
 function getBlockInputsAndOutputs(componentOrDirectives) {
     const inputs = new Set();
     const outputs = new Set();
@@ -2472,22 +2633,50 @@ function getBlockInputsAndOutputs(componentOrDirectives) {
     }
     return { inputs, outputs, twoWay };
 }
+function isTwoWayInput(publicName, publicOutputKeys, _inputDef, outputsRecord) {
+    const changeOutputName = `${publicName}Change`;
+    // model(): def.outputs is { value: 'valueChange' } (key = input name, not *Change)
+    if (outputsRecord?.[publicName] === changeOutputName) {
+        return true;
+    }
+    // @Input + @Output *Change, or signal/model inputs with a public *Change output
+    return publicOutputKeys.has(changeOutputName);
+}
 function getDirectiveMetadata(type) {
-    // Directives have ɵdir, Components have ɵcmp
-    const def = type.ɵdir || type.ɵcmp;
+    const angularType = type;
+    if (angularType.ɵcmp) {
+        const mirror = reflectComponentType(type);
+        if (mirror != null && mirror.inputs.length > 0) {
+            const outputNames = new Set(mirror.outputs.map((o) => o.templateName));
+            const twoWay = [];
+            const inputs = [];
+            for (const inp of mirror.inputs) {
+                const name = inp.templateName;
+                if (isTwoWayInput(name, outputNames, null, undefined)) {
+                    twoWay.push(name);
+                }
+                else {
+                    inputs.push(name);
+                }
+            }
+            const outputs = mirror.outputs.map((o) => o.templateName);
+            return { inputs, outputs, twoWay, isComponent: true };
+        }
+    }
+    // Directives have ɵdir, Components have ɵcmp (fallback when mirror is empty)
+    const def = angularType.ɵdir || angularType.ɵcmp;
     if (!def)
         return null;
-    // def.inputs and def.outputs are objects where:
-    // Key = Public Template Name (alias)
-    // Value = Internal Class Property Name
-    const publicInputs = Object.keys(def.inputs || {});
-    const publicOutputs = Object.keys(def.outputs || {});
-    const twoWay = publicInputs.filter((key) => publicOutputs.includes(`${key}Change`) && def.inputs[key][1]);
+    const inputsRecord = def.inputs || {};
+    const outputsRecord = def.outputs || {};
+    const publicInputs = Object.keys(inputsRecord);
+    const publicOutputs = new Set(Object.keys(outputsRecord));
+    const twoWay = publicInputs.filter((key) => isTwoWayInput(key, publicOutputs, inputsRecord[key], outputsRecord));
     return {
         inputs: publicInputs.filter((key) => !twoWay.includes(key)),
-        outputs: publicOutputs.filter((key) => !twoWay.includes(key)),
+        outputs: [...publicOutputs].filter((key) => !twoWay.includes(key)),
         twoWay,
-        isComponent: !!type.ɵcmp,
+        isComponent: !!angularType.ɵcmp,
     };
 }
 function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWayKeys, ctx) {
@@ -2539,13 +2728,15 @@ function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWay
                 continue;
             }
         }
-        if (Array.isArray(value)) {
-            resolvedInputs[key] = computed(() => value.map((item) => {
-                if (typeof item === 'string') {
-                    return resolveTemplateString(item, ctx, undefined, { escapeFlowRefs: true });
-                }
-                return item;
-            }));
+        if (Array.isArray(value) || isPlainObject(value)) {
+            if (valueNeedsInputResolve(value)) {
+                resolvedInputs[key] = computed(() => resolveNestedTemplateValues(value, ctx, key, new WeakSet(), NESTED_INPUT_RESOLVE_OPTIONS));
+            }
+            else if (inputKeys.has(key)) {
+                resolvedInputs[key] = () => value;
+            }
+            if (twoWayKeys.has(key))
+                resolvedTwoWay[key] = signal(value);
             continue;
         }
         if (inputKeys.has(key))
@@ -2564,6 +2755,10 @@ function resolveBlockInputsAndOutputs(description, inputKeys, outputKeys, twoWay
 }
 
 const INTERPOLATE_MAX_PLACEHOLDERS = 200;
+/** Builds a two-way binding when only a read getter exists for the key (used by {@link createInputBindingsWithWarnings}). */
+function linkedTwoWayFromInputGetter(resolvedInputs, key) {
+    return linkedSignal(() => resolvedInputs[key]?.());
+}
 function createInputBindingsWithWarnings(ownerName, inputKeys, twoWayKeys, outputKeys, resolvedInputs, resolvedTwoWay, resolvedOutputs) {
     const inputBindingsArray = Array.from(inputKeys)
         .filter((key) => {
@@ -2582,7 +2777,7 @@ function createInputBindingsWithWarnings(ownerName, inputKeys, twoWayKeys, outpu
     })
         // resolvedTwoWay is guaranteed non-null after the filter.
         .map((key) => twoWayBinding(key, (resolvedTwoWay[key] ??
-        linkedSignal(() => resolvedInputs[key]?.()))));
+        linkedTwoWayFromInputGetter(resolvedInputs, key))));
     const outputBindingsArray = Array.from(outputKeys)
         .filter((key) => {
         if (resolvedOutputs[key] == null) {
@@ -2593,15 +2788,6 @@ function createInputBindingsWithWarnings(ownerName, inputKeys, twoWayKeys, outpu
         .map((key) => outputBinding(key, resolvedOutputs[key]));
     return [...inputBindingsArray, ...twoWayBindingsArray, ...outputBindingsArray];
 }
-/** JSON-like objects only — skip class instances, Date, Map, etc. */
-function isPlainObject(value) {
-    if (value === null || typeof value !== 'object')
-        return false;
-    if (Array.isArray(value))
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === null || proto === Object.prototype;
-}
 class BlockLoaderService {
     componentRegistry = ComponentRegistry.getInstance();
     directiveRegistry = DirectiveRegistry.getInstance();
@@ -2780,9 +2966,9 @@ class BlockLoaderService {
             }
         }
         else {
-            const hasTemplates = this.valueContainsTemplate(directiveModel);
+            const hasTemplates = valueContainsMustacheInTree(directiveModel);
             blockInstanceModel = hasTemplates
-                ? linkedSignal(() => this.resolveNestedModelTemplates(blockModel(), this.withModelOverrideContext(ctx, blockModel)))
+                ? linkedSignal(() => resolveNestedTemplateValues(blockModel(), this.withModelOverrideContext(ctx, blockModel), 'model', new WeakSet(), { resolveTwoWayStringsAsReadonly: false }))
                 : blockModel;
         }
         if (blockInstanceModel != null) {
@@ -2792,43 +2978,6 @@ class BlockLoaderService {
             blockInstance.model = blockInstanceModel;
         }
     }
-    valueContainsTemplate(value, visited = new WeakSet()) {
-        if (typeof value === 'string') {
-            return value.includes('{{') && value.includes('}}');
-        }
-        if (Array.isArray(value)) {
-            return value.some((item) => this.valueContainsTemplate(item, visited));
-        }
-        if (value != null && typeof value === 'object') {
-            if (!isPlainObject(value))
-                return false;
-            if (visited.has(value))
-                return false;
-            visited.add(value);
-            return Object.values(value).some((item) => this.valueContainsTemplate(item, visited));
-        }
-        return false;
-    }
-    resolveNestedModelTemplates(value, ctx, visited = new WeakSet()) {
-        if (typeof value === 'string') {
-            return resolveTemplateString(value, ctx);
-        }
-        if (Array.isArray(value)) {
-            return value.map((item) => this.resolveNestedModelTemplates(item, ctx, visited));
-        }
-        if (value != null && typeof value === 'object') {
-            if (!isPlainObject(value))
-                return value;
-            if (visited.has(value))
-                return value;
-            visited.add(value);
-            return Object.fromEntries(Object.entries(value).map(([key, item]) => [
-                key,
-                this.resolveNestedModelTemplates(item, ctx, visited),
-            ]));
-        }
-        return value;
-    }
     withModelOverrideContext(ctx, model) {
         if (ctx.currentInstance == null)
             return ctx;
@@ -2840,10 +2989,10 @@ class BlockLoaderService {
             },
         };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockLoaderService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockLoaderService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockLoaderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockLoaderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -2867,10 +3016,117 @@ function safeJsonKey(value) {
         return String(value);
     }
 }
+
+function createInitialBlockDirectiveLoadState() {
+    return {
+        loadResult: null,
+        lastRegistry: null,
+        lastId: null,
+        loadedComponent: null,
+        loadedServicesKey: null,
+        loadedReloadKey: null,
+        loadedDescKey: null,
+        loadGeneration: 0,
+        effectRunId: 0,
+        lastDescRef: null,
+        lastParsedData: null,
+    };
+}
+function clearBlockDirective(state, viewContainerRef) {
+    state.loadGeneration++;
+    state.lastDescRef = null;
+    state.lastParsedData = null;
+    if (state.lastId != null) {
+        state.lastRegistry?.unregister(state.lastId);
+        state.lastId = null;
+    }
+    if (state.loadResult) {
+        viewContainerRef.clear();
+        state.loadResult = null;
+        state.loadedComponent = null;
+        state.loadedServicesKey = null;
+        state.loadedReloadKey = null;
+        state.loadedDescKey = null;
+    }
+}
+function runBlockDirectiveEffect(state, ctx, desc, inputDefs, blockRegistry, reloadKey) {
+    const runId = ++state.effectRunId;
+    if (desc == null) {
+        state.lastDescRef = null;
+        state.lastParsedData = null;
+        clearBlockDirective(state, ctx.viewContainerRef);
+        return;
+    }
+    const runAfterResolved = (resolved) => {
+        if (runId !== state.effectRunId) {
+            return;
+        }
+        let data;
+        if (resolved === state.lastDescRef && state.lastParsedData != null) {
+            data = state.lastParsedData;
+        }
+        else {
+            const parsed = safeParseBlockDescription(resolved);
+            if (!parsed.success) {
+                return;
+            }
+            state.lastDescRef = resolved;
+            state.lastParsedData = parsed.data;
+            data = parsed.data;
+        }
+        const servicesKey = getServicesKey(data.services);
+        const descKey = safeJsonKey(resolved);
+        const effectiveReloadKey = reloadKey ?? descKey;
+        const mustReload = state.loadResult == null ||
+            state.loadedComponent !== data.component ||
+            state.loadedServicesKey !== servicesKey ||
+            state.loadedReloadKey !== effectiveReloadKey ||
+            state.loadedDescKey !== descKey;
+        if (!mustReload) {
+            return;
+        }
+        clearBlockDirective(state, ctx.viewContainerRef);
+        const registry = blockRegistry ?? undefined;
+        state.lastRegistry = registry ?? null;
+        state.lastId = data.id ?? null;
+        const generation = ++state.loadGeneration;
+        ctx
+            .loadBlock(resolved, registry, inputDefs ?? undefined)
+            .then((result) => {
+            if (generation !== state.loadGeneration)
+                return;
+            state.loadResult = result;
+            state.loadedComponent = data.component;
+            state.loadedServicesKey = servicesKey;
+            state.loadedReloadKey = effectiveReloadKey;
+            state.loadedDescKey = descKey;
+        })
+            .catch((err) => {
+            if (generation !== state.loadGeneration)
+                return;
+            console.error('Block load failed:', err);
+        });
+    };
+    if (isBlockReference(desc)) {
+        void resolveBlockReference(desc, inputDefs ?? undefined)
+            .then((resolved) => {
+            runAfterResolved(resolved);
+        })
+            .catch((err) => {
+            if (runId !== state.effectRunId)
+                return;
+            console.error('Block reference resolution failed:', err);
+        });
+        return;
+    }
+    runAfterResolved(desc);
+}
+
 class BlockDirective {
     viewContainerRef = inject(ViewContainerRef);
     loader = inject(BlockLoaderService);
     destroyRef = inject(DestroyRef);
+    loadState = createInitialBlockDirectiveLoadState();
     /** Full description, or { id } / { blockId, blockDefinition? } to reuse/override from blockDefinitions. */
     description = input(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "description" }] : /* istanbul ignore next */ []));
@@ -2889,124 +3145,25 @@ class BlockDirective {
      */
     reloadKey = input(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "reloadKey" }] : /* istanbul ignore next */ []));
-    loadResult = null;
-    lastRegistry = null;
-    lastId = null;
-    loadedComponent = null;
-    loadedServicesKey = null;
-    loadedReloadKey = null;
-    loadedDescKey = null;
-    loadGeneration = 0;
-    /** Invalidates in-flight block-reference resolution when the effect re-runs. */
-    effectRunId = 0;
-    /** Avoid re-parsing when the same description reference is passed (e.g. stable signal). */
-    lastDescRef = null;
-    lastParsedData = null;
+    loadBlock(resolved, registry, blockDefinitions) {
+        return this.loader.load(resolved, this.viewContainerRef, this.model, {
+            registry,
+            blockDefinitions,
+        });
+    }
     constructor() {
         effect(() => {
-            const desc = this.description();
-            const inputDefs = this.blockDefinitions();
-            const reloadKey = this.reloadKey();
-            const runId = ++this.effectRunId;
-            if (desc == null) {
-                this.lastDescRef = null;
-                this.lastParsedData = null;
-                this.clear();
-                return;
-            }
-            const runAfterResolved = (resolved) => {
-                if (runId !== this.effectRunId) {
-                    return;
-                }
-                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 descKey = safeJsonKey(resolved);
-                const effectiveReloadKey = reloadKey ?? descKey;
-                // Only clear when the logical description changed (component or services). Avoids
-                // clear+reload when the parent passes a new reference with the same content (e.g. BlockFor).
-                const mustReload = this.loadResult == null ||
-                    this.loadedComponent !== data.component ||
-                    this.loadedServicesKey !== servicesKey ||
-                    this.loadedReloadKey !== effectiveReloadKey ||
-                    this.loadedDescKey !== descKey;
-                if (!mustReload) {
-                    // Description is logically unchanged (same component + services); no work needed.
-                    return;
-                }
-                this.clear();
-                const registry = this.blockRegistry() ?? undefined;
-                this.lastRegistry = registry ?? null;
-                this.lastId = data.id ?? null;
-                const generation = ++this.loadGeneration;
-                this.loader
-                    .load(resolved, this.viewContainerRef, this.model, {
-                    registry,
-                    blockDefinitions: inputDefs ?? undefined,
-                })
-                    .then((result) => {
-                    if (generation !== this.loadGeneration)
-                        return;
-                    this.loadResult = result;
-                    this.loadedComponent = data.component;
-                    this.loadedServicesKey = servicesKey;
-                    this.loadedReloadKey = effectiveReloadKey;
-                    this.loadedDescKey = descKey;
-                })
-                    .catch((err) => {
-                    if (generation !== this.loadGeneration)
-                        return;
-                    console.error('Block load failed:', err);
-                });
-            };
-            if (isBlockReference(desc)) {
-                void resolveBlockReference(desc, inputDefs ?? undefined)
-                    .then((resolved) => {
-                    runAfterResolved(resolved);
-                })
-                    .catch((err) => {
-                    if (runId !== this.effectRunId)
-                        return;
-                    console.error('Block reference resolution failed:', err);
-                });
-                return;
-            }
-            runAfterResolved(desc);
+            runBlockDirectiveEffect(this.loadState, {
+                viewContainerRef: this.viewContainerRef,
+                loadBlock: this.loadBlock.bind(this),
+            }, this.description(), this.blockDefinitions(), this.blockRegistry(), this.reloadKey());
         });
-        this.destroyRef.onDestroy(() => this.clear());
+        this.destroyRef.onDestroy(() => clearBlockDirective(this.loadState, this.viewContainerRef));
     }
-    clear() {
-        this.loadGeneration++;
-        this.lastDescRef = null;
-        this.lastParsedData = null;
-        if (this.lastId != null) {
-            this.lastRegistry?.unregister(this.lastId);
-            this.lastId = null;
-        }
-        if (this.loadResult) {
-            this.viewContainerRef.clear();
-            this.loadResult = null;
-            this.loadedComponent = null;
-            this.loadedServicesKey = null;
-            this.loadedReloadKey = null;
-            this.loadedDescKey = null;
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.7", type: BlockDirective, isStandalone: true, selector: "[block]", inputs: { description: { classPropertyName: "description", publicName: "description", 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 }, reloadKey: { classPropertyName: "reloadKey", publicName: "reloadKey", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImport: i0, type: BlockDirective, decorators: [{
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.2.3", type: BlockDirective, isStandalone: true, selector: "[block]", inputs: { description: { classPropertyName: "description", publicName: "description", 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 }, reloadKey: { classPropertyName: "reloadKey", publicName: "reloadKey", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.3", ngImport: i0, type: BlockDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[block]',
@@ -3022,5 +3179,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { BlockDefinitionsRegistry, BlockDirective, BlockLoaderService, BlockRegistryImpl, BlockRegistryService, ChainedBlockRegistry, ComponentRegistry, DirectiveRegistry, GuardRegistry, INTERPOLATE_MAX_PLACEHOLDERS, RegistryMetadataStore, RouteLoader, ServiceRegistry, buildComputedForTemplate, classifyTwoWayString, collectRefPaths, createOutputHandler, deepMergeBlockDefinition, evaluateExpression, extractReadonlyRefs, getRefPathFromReadonly, getRefSignal, getRefValue, getValueByPath, interpretFlow, isBlockDefinitionLoader, isBlockReference, isInvalidTwoWayMix, isOutputCallObject, isOutputReference, isTwoWayRefString, looksLikeFlowTemplate, mustacheSegmentToString, normalizeDirectives, normalizeServices, parseFlowTemplate, parseRefPath, parseTwoWayRef, refPathResolvesToSignal, resolveBlockReference, resolveMustacheInterpolatedString, resolveRefOrModel, resolveRefPath, resolveReferenceValue, resolveTemplateString, safeParseBlockDescription, setRefValue, splitCallableRef };
+export { BlockDefinitionsRegistry, BlockDirective, BlockLoaderService, BlockRegistryImpl, BlockRegistryService, ChainedBlockRegistry, ComponentRegistry, DirectiveRegistry, GuardRegistry, INTERPOLATE_MAX_PLACEHOLDERS, RegistryMetadataStore, RouteLoader, ServiceRegistry, buildComputedForTemplate, classifyTwoWayString, collectRefPaths, createInputBindingsWithWarnings, createOutputHandler, deepMergeBlockDefinition, evaluateExpression, extractReadonlyRefs, getRefPathFromReadonly, getRefSignal, getRefValue, getValueByPath, interpretFlow, isBlockDefinitionLoader, isBlockReference, isInvalidTwoWayMix, isOutputCallObject, isOutputReference, isPlainObject, isTwoWayRefString, linkedTwoWayFromInputGetter, looksLikeBlockDescriptor, looksLikeFlowTemplate, mustacheSegmentToString, normalizeDirectives, normalizeServices, parseFlowTemplate, parseRefPath, parseTwoWayRef, refPathResolvesToSignal, resolveBlockReference, resolveMustacheInterpolatedString, resolveNestedTemplateValues, resolveRefOrModel, resolveRefPath, resolveReferenceValue, resolveTemplateString, safeParseBlockDescription, setRefValue, shouldDeferInputTemplateResolution, splitCallableRef, valueContainsMustacheInTree, valueNeedsInputResolve };
 //# sourceMappingURL=ngx-blocks-studio.mjs.map