ngx-blocks-studio 0.1.1 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ngx-blocks-studio",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/winghei/ngx-blocks-studio.git"

package/types/ngx-blocks-studio.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { Type, Injector, Signal, ViewContainerRef, ComponentRef } from '@angular/core';
+import { Type, Injector, Signal, ViewContainerRef, ComponentRef, WritableSignal } from '@angular/core';
 import { CanActivateFn, RunGuardsAndResolvers } from '@angular/router';
 
 /**
@@ -306,7 +306,7 @@ declare class RouteLoader {
     private loadComponent;
     private getGuard;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RouteLoader, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RouteLoader>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 interface CurrentInstance {
@@ -380,7 +380,7 @@ declare class BlockRegistryService {
     getRegistryForScope(scopeKey: string): BlockRegistry | null;
     getParentScopeKey(scopeKey: string): string | null;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockRegistryService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BlockRegistryService>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 /**
@@ -507,8 +507,9 @@ declare function parseRefPath(refPath: string): ParsedRefPath;
 declare function extractReadonlyRefs(template: string): string[];
 declare function isTwoWayRefString(value: unknown): value is string;
 /**
- * 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.
  */
 declare function isInvalidTwoWayMix(value: unknown): value is string;
 /**
@@ -660,6 +661,9 @@ interface BlockLoadOptions {
     blockDefinitions?: Record<string, BlockDefinitionOrLoader>;
 }
 declare const INTERPOLATE_MAX_PLACEHOLDERS = 200;
+/** Builds a two-way binding when only a read getter exists for the key (used by {@link createInputBindingsWithWarnings}). */
+declare function linkedTwoWayFromInputGetter(resolvedInputs: Record<string, (() => unknown) | undefined>, key: string): WritableSignal<unknown>;
+declare function createInputBindingsWithWarnings(ownerName: string, inputKeys: Set<string>, twoWayKeys: Set<string>, outputKeys: Set<string>, resolvedInputs: Record<string, (() => unknown) | undefined>, resolvedTwoWay: Record<string, unknown>, resolvedOutputs: Record<string, (value: unknown) => void>): _angular_core.Binding[];
 declare class BlockLoaderService {
     private readonly componentRegistry;
     private readonly directiveRegistry;
@@ -674,17 +678,16 @@ declare class BlockLoaderService {
     private getDirectiveTypes;
     /** Resolve model from desc (interpolate ref if string) and set on blockInstance. */
     private resolveContextModel;
-    private valueContainsTemplate;
-    private resolveNestedModelTemplates;
     private withModelOverrideContext;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockLoaderService, never>;
-    static ɵprov: _angular_core.ɵɵInjectableDeclaration<BlockLoaderService>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
 }
 
 declare class BlockDirective {
     private readonly viewContainerRef;
     private readonly loader;
     private readonly destroyRef;
+    private readonly loadState;
     /** Full description, or { id } / { blockId, blockDefinition? } to reuse/override from blockDefinitions. */
     readonly description: _angular_core.InputSignal<BlockInput | BlockReference | null>;
     /** Registry for block instances by id; pass from root so nested blocks share it. */
@@ -698,24 +701,37 @@ declare class BlockDirective {
      * Useful for "same component, different inputs" scenarios like tabs/switch blocks.
      */
     readonly reloadKey: _angular_core.InputSignal<unknown>;
-    private loadResult;
-    private lastRegistry;
-    private lastId;
-    private loadedComponent;
-    private loadedServicesKey;
-    private loadedReloadKey;
-    private loadedDescKey;
-    private loadGeneration;
-    /** Invalidates in-flight block-reference resolution when the effect re-runs. */
-    private effectRunId;
-    /** Avoid re-parsing when the same description reference is passed (e.g. stable signal). */
-    private lastDescRef;
-    private lastParsedData;
+    loadBlock(resolved: BlockInput | BlockReference, registry?: BlockRegistry, blockDefinitions?: Record<string, BlockDefinitionOrLoader>): Promise<_angular_core.ComponentRef<unknown>>;
     constructor();
-    private clear;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockDirective, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BlockDirective, "[block]", never, { "description": { "alias": "description"; "required": false; "isSignal": true; }; "blockRegistry": { "alias": "blockRegistry"; "required": false; "isSignal": true; }; "blockDefinitions": { "alias": "blockDefinitions"; "required": false; "isSignal": true; }; "model": { "alias": "model"; "required": false; "isSignal": true; }; "reloadKey": { "alias": "reloadKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-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 type { AllRegistryMetadata, BlockDefinitionLoader, BlockDefinitionOrLoader, BlockDescription, BlockInput, BlockInstanceHandle, BlockLoadOptions, BlockOutputValue, BlockReference, BlockRegistry, CurrentInstance, FlowNode, FlowScope, GuardLoader, GuardOrLoader, GuardOrType, InterpretFlowOptions, OutputCallObject, OutputOnError, OutputReference, ParsedRefPath, RegistryEntryType, RegistryMetadataRecord, ResolveTemplateStringOptions, ResolverContext, RouteConfig, RouteConfigs, SafeParseBlockDescriptionResult, ScopedRegistryNode, ServiceEntry, ThenChainStep };
+/** JSON-like objects only — skip class instances, Date, Map, etc. */
+declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+/**
+ * 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.
+ */
+declare function looksLikeBlockDescriptor(value: unknown): boolean;
+/** Same as {@link looksLikeBlockDescriptor}; use in custom layout blocks if needed. */
+declare const shouldDeferInputTemplateResolution: typeof looksLikeBlockDescriptor;
+/** True when any string leaf in the tree needs input-style resolution (mustache, flow, or `[( )]`). */
+declare function valueNeedsInputResolve(value: unknown, visited?: WeakSet<object>): boolean;
+/** True when any string leaf contains `{{ }}` (block model seeding). */
+declare function valueContainsMustacheInTree(value: unknown, visited?: WeakSet<object>): boolean;
+interface ResolveNestedTemplateOptions {
+    /**
+     * When true, exact `[(refPath)]` strings resolve to the current ref value (read-only).
+     * Does not create Angular two-way bindings on nested keys.
+     */
+    resolveTwoWayStringsAsReadonly?: boolean;
+    escapeFlowRefs?: boolean;
+}
+/**
+ * Deep-resolve template strings in plain objects and arrays (new object graph each call).
+ */
+declare function resolveNestedTemplateValues(value: unknown, ctx: ResolverContext, path?: string, visited?: WeakSet<object>, options?: ResolveNestedTemplateOptions): unknown;
+
+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 };
+export type { AllRegistryMetadata, BlockDefinitionLoader, BlockDefinitionOrLoader, BlockDescription, BlockInput, BlockInstanceHandle, BlockLoadOptions, BlockOutputValue, BlockReference, BlockRegistry, CurrentInstance, FlowNode, FlowScope, GuardLoader, GuardOrLoader, GuardOrType, InterpretFlowOptions, OutputCallObject, OutputOnError, OutputReference, ParsedRefPath, RegistryEntryType, RegistryMetadataRecord, ResolveNestedTemplateOptions, ResolveTemplateStringOptions, ResolverContext, RouteConfig, RouteConfigs, SafeParseBlockDescriptionResult, ScopedRegistryNode, ServiceEntry, ThenChainStep };