@ng-forge/dynamic-forms 1.0.0-rc.1 → 1.0.0-rc.3

package/fesm2022/ng-forge-dynamic-forms-internal.mjs

@@ -1,11 +1,274 @@
 import * as i0 from '@angular/core';
-import { isSignal, untracked, InjectionToken, inject, Injectable, linkedSignal, resourceFromSnapshots, signal, Injector, computed, Pipe } from '@angular/core';
-import { defer, combineLatest, pipe, debounceTime, distinctUntilChanged, of, from, map, catchError, tap, startWith, Subject, filter, isObservable, TimeoutError, throwError } from 'rxjs';
-import { toObservable, toSignal, rxResource } from '@angular/core/rxjs-interop';
+import { InjectionToken, computed, isSignal, inject, Injector, input, signal, ChangeDetectionStrategy, Component, untracked, Injectable, linkedSignal, resourceFromSnapshots, Pipe } from '@angular/core';
+import { NgComponentOutlet } from '@angular/common';
+import { explicitEffect } from 'ngxtension/explicit-effect';
+import { toSignal, toObservable, rxResource } from '@angular/core/rxjs-interop';
+import { isObservable, defer, combineLatest, pipe, debounceTime, distinctUntilChanged, of, from, map, catchError, tap, startWith, Subject, filter, TimeoutError, throwError } from 'rxjs';
 import { HttpClient } from '@angular/common/http';
 import { email, min, max, minLength, maxLength, pattern, required, validate, validateAsync, validateHttp } from '@angular/forms/signals';
 import { scan, map as map$1, filter as filter$1, take, switchMap, timeout, catchError as catchError$1, shareReplay } from 'rxjs/operators';
 
+const ADDON_TYPE_DEFINITIONS = new InjectionToken('ADDON_TYPE_DEFINITIONS');
+
+const DynamicFormLogger = new InjectionToken('DynamicFormLogger');
+
+function resolveDynamicValue(value, fallback, injector) {
+    if (value === undefined) {
+        return computed(() => fallback);
+    }
+    if (isSignal(value)) {
+        return value;
+    }
+    if (isObservable(value)) {
+        return toSignal(value, { initialValue: fallback, injector });
+    }
+        return computed(() => value);
+}
+
+class DynamicFormError extends Error {
+    static PREFIX = '[Dynamic Forms]';
+    constructor(message) {
+        super(`${DynamicFormError.PREFIX} ${message}`);
+        this.name = 'DynamicFormError';
+    }
+}
+
+const ADDON_TYPE_REGISTRY = new InjectionToken('ADDON_TYPE_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+const ADDON_TYPE_COMPONENT_CACHE = new InjectionToken('ADDON_TYPE_COMPONENT_CACHE');
+
+function resolveDefaultExport(result) {
+    return typeof result === 'object' && result !== null && 'default' in result ? result.default : result;
+}
+function injectAddonTypeRegistry() {
+    const registry = inject(ADDON_TYPE_REGISTRY);
+    const componentCache = inject(ADDON_TYPE_COMPONENT_CACHE);
+    return {
+                getType(type) {
+            return registry.get(type);
+        },
+                hasType(type) {
+            return registry.has(type);
+        },
+                getTypeNames() {
+            return Array.from(registry.keys());
+        },
+                async loadTypeComponent(type) {
+            const definition = registry.get(type);
+            if (!definition) {
+                const known = Array.from(registry.keys()).join(', ') || '(none)';
+                throw new DynamicFormError(`Addon type '${type}' is not registered. Currently registered types: ${known}.`);
+            }
+            const cached = componentCache.get(type);
+            if (cached) {
+                return cached;
+            }
+            try {
+                const component = resolveDefaultExport(await definition.loadComponent());
+                if (component) {
+                    componentCache.set(type, component);
+                    return component;
+                }
+                throw new DynamicFormError(`Addon type '${type}' loadComponent resolved to null.`);
+            }
+            catch (error) {
+                if (error instanceof DynamicFormError)
+                    throw error;
+                throw new DynamicFormError(`Failed to load component for addon type '${type}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+                getLoadedTypeComponent(type) {
+            if (!registry.has(type))
+                return undefined;
+            return componentCache.get(type);
+        },
+                get raw() {
+            return registry;
+        },
+    };
+}
+
+class DfAddonSlot {
+    registry = injectAddonTypeRegistry();
+    logger = inject(DynamicFormLogger);
+    hostInjector = inject(Injector);
+    addon = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "addon" }] : /* istanbul ignore next */ []));
+        fieldInputs = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "fieldInputs" }] : /* istanbul ignore next */ []));
+        hidden = input(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hidden" }] : /* istanbul ignore next */ []));
+        slotAttr = computed(() => this.addon().slot, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "slotAttr" }] : /* istanbul ignore next */ []));
+    className = computed(() => this.addon().className ?? null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "className" }] : /* istanbul ignore next */ []));
+        _hiddenByValue = new WeakMap();
+    _resolvedHidden = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "_resolvedHidden" }] : /* istanbul ignore next */ []));
+        isHidden = computed(() => {
+        const pre = this.hidden();
+        if (pre)
+            return pre();
+        const local = this._resolvedHidden();
+        return local ? local() : false;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isHidden" }] : /* istanbul ignore next */ []));
+        asyncLoaded = signal(undefined, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "asyncLoaded" }] : /* istanbul ignore next */ []));
+        resolvedComponent = computed(() => {
+        const type = this.addon().type;
+        const cached = this.registry.getLoadedTypeComponent(type);
+        if (cached)
+            return cached;
+        const loaded = this.asyncLoaded();
+        return loaded?.type === type ? loaded.component : undefined;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedComponent" }] : /* istanbul ignore next */ []));
+        typeInputs = computed(() => ({
+        addon: this.addon(),
+        fieldInputs: this.fieldInputs(),
+    }), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "typeInputs" }] : /* istanbul ignore next */ []));
+    constructor() {
+                                        explicitEffect([this.addon], ([addon]) => {
+            const h = addon.hidden;
+            const valueKey = typeof h === 'object' && h !== null ? h : null;
+            let resolved = valueKey ? this._hiddenByValue.get(valueKey) : undefined;
+            if (!resolved) {
+                resolved = resolveDynamicValue(addon.hidden, false, this.hostInjector);
+                if (valueKey)
+                    this._hiddenByValue.set(valueKey, resolved);
+            }
+            this._resolvedHidden.set(resolved);
+        });
+                        explicitEffect([this.addon], ([addon]) => {
+            const type = addon.type;
+            if (this.registry.getLoadedTypeComponent(type))
+                return;             this.registry
+                .loadTypeComponent(type)
+                .then((component) => this.asyncLoaded.set({ type, component }))
+                .catch((error) => {
+                this.logger.warn(`Failed to load addon type '${type}': ${error instanceof Error ? error.message : String(error)}. ` +
+                    `Registered types: ${this.registry.getTypeNames().join(', ') || '(none)'}.`);
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DfAddonSlot, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.0", type: DfAddonSlot, isStandalone: true, selector: "df-addon-slot", inputs: { addon: { classPropertyName: "addon", publicName: "addon", isSignal: true, isRequired: true, transformFunction: null }, fieldInputs: { classPropertyName: "fieldInputs", publicName: "fieldInputs", isSignal: true, isRequired: false, transformFunction: null }, hidden: { classPropertyName: "hidden", publicName: "hidden", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "attr.slot": "slotAttr()", "class": "className()", "style.display": "isHidden() ? \"none\" : null" } }, ngImport: i0, template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: typeInputs()" />
+    }
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: DfAddonSlot, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'df-addon-slot',
+                    imports: [NgComponentOutlet],
+                    template: `
+    @if (resolvedComponent(); as cmp) {
+      <ng-container *ngComponentOutlet="cmp; inputs: typeInputs()" />
+    }
+  `,
+                    host: {
+                        '[attr.slot]': 'slotAttr()',
+                        '[class]': 'className()',
+                        '[style.display]': 'isHidden() ? "none" : null',
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: () => [], propDecorators: { addon: [{ type: i0.Input, args: [{ isSignal: true, alias: "addon", required: true }] }], fieldInputs: [{ type: i0.Input, args: [{ isSignal: true, alias: "fieldInputs", required: false }] }], hidden: [{ type: i0.Input, args: [{ isSignal: true, alias: "hidden", required: false }] }] } });
+
+const FIELD_REGISTRY = new InjectionToken('FIELD_REGISTRY', {
+    providedIn: 'root',
+    factory: () => new Map(),
+});
+function getFieldValueHandling(fieldType, registry) {
+    const definition = registry.get(fieldType);
+    return definition?.valueHandling ?? 'include';
+}
+
+function injectFieldsSupportingAddons() {
+    const registry = inject(FIELD_REGISTRY);
+    const entries = [];
+    for (const [name, def] of registry.entries()) {
+        if (def.addons === undefined)
+            continue;
+        entries.push({ name, slots: def.addons.slots, allowedTypes: def.addons.allowedTypes });
+    }
+    return entries;
+}
+
+async function runPresetAction(preset, ctx, collaborators, adapterLabel, fieldLabel) {
+                                if (ctx.form === null && preset !== 'copy' && preset !== 'paste') {
+        collaborators.logger.warn(`preset '${String(preset)}' fired without a host field context — ignoring.`);
+        return;
+    }
+                if (ctx.form !== null && (preset === 'clear' || preset === 'reset' || preset === 'paste') && ctx.form.disabled()) {
+        collaborators.logger.warn(`preset '${String(preset)}' skipped — host '${fieldLabel}' is disabled.`);
+        return;
+    }
+    switch (preset) {
+        case 'clear': {
+                                                const next = typeof ctx.value === 'string' ? '' : undefined;
+            collaborators.fieldValueSetter?.(next);
+            return;
+        }
+        case 'reset': {
+            const defaultValue = collaborators.fieldDefaultValueGetter?.();
+            collaborators.fieldValueSetter?.(defaultValue !== undefined ? defaultValue : typeof ctx.value === 'string' ? '' : undefined);
+            return;
+        }
+        case 'paste': {
+            if (typeof navigator === 'undefined' || !navigator.clipboard) {
+                collaborators.logger.warn(`preset 'paste' requires a browser clipboard API (not available in this environment).`);
+                return;
+            }
+            try {
+                const text = await navigator.clipboard.readText();
+                collaborators.fieldValueSetter?.(text);
+            }
+            catch (error) {
+                collaborators.logger.warn(`preset 'paste' clipboard read failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        case 'copy': {
+            if (typeof navigator === 'undefined' || !navigator.clipboard) {
+                collaborators.logger.warn(`preset 'copy' requires a browser clipboard API (not available in this environment).`);
+                return;
+            }
+            try {
+                                                const v = ctx.value;
+                await navigator.clipboard.writeText(v == null ? '' : String(v));
+            }
+            catch (error) {
+                collaborators.logger.warn(`preset 'copy' clipboard write failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+        case 'toggle-password-visibility': {
+            const override = collaborators.typeOverride;
+            if (!override) {
+                collaborators.logger.warn(`preset 'toggle-password-visibility' has no effect outside a '${fieldLabel}' field.`);
+                return;
+            }
+                                                                                    const baseline = collaborators.baselineType?.();
+            if (baseline !== undefined && baseline !== 'password') {
+                collaborators.logger.warn(`preset 'toggle-password-visibility' refused: host '${fieldLabel}' has type '${baseline}', not 'password'.`);
+                return;
+            }
+            const current = override();
+            override.set(current === 'text' ? 'password' : 'text');
+            return;
+        }
+        default:
+            collaborators.logger.warn(`preset '${String(preset)}' is not implemented in the ${adapterLabel} adapter.`);
+    }
+}
+
 function createDefaultDerivationLogConfig() {
     return {
         level: 'none',
@@ -228,14 +491,6 @@ function stableStringify(value) {
     return '{' + pairs.join(',') + '}';
 }
 
-class DynamicFormError extends Error {
-    static PREFIX = '[Dynamic Forms]';
-    constructor(message) {
-        super(`${DynamicFormError.PREFIX} ${message}`);
-        this.name = 'DynamicFormError';
-    }
-}
-
 const DEFAULT_WRAPPERS = new InjectionToken('DEFAULT_WRAPPERS');
 const FIELD_SIGNAL_CONTEXT = new InjectionToken('FIELD_SIGNAL_CONTEXT');
 function injectFieldSignalContext() {
@@ -262,8 +517,6 @@ class RootFormRegistryService {
     }
 }
 
-const DynamicFormLogger = new InjectionToken('DynamicFormLogger');
-
 const DEPRECATION_WARNING_TRACKER = new InjectionToken('DeprecationWarningTracker');
 
 function compareValues(actual, expected, operator) {
@@ -2549,7 +2802,7 @@ function isSimplifiedArrayField(field) {
     return field.type === 'array' && 'template' in field;
 }
 
-function isContainerTypedField(field) {
+function isGenericContainerField(field) {
     return (field.type === 'container' &&
         'wrappers' in field &&
         'fields' in field &&
@@ -2576,7 +2829,7 @@ function validatePageNesting(pageField) {
     return !hasNestedPages(pageField.fields);
 }
 function isContainerWithFields$1(field) {
-    return ((isRowField(field) || isGroupField(field) || isContainerTypedField(field)) &&
+    return ((isRowField(field) || isGroupField(field) || isGenericContainerField(field)) &&
         'fields' in field &&
         Array.isArray(field.fields));
 }
@@ -2873,22 +3126,21 @@ function isFieldBoundContext(ctx) {
     return ctx.form !== null;
 }
 
-const ADDON_KIND_REGISTRY = new InjectionToken('ADDON_KIND_REGISTRY', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
+const ADDON_ACTION_HANDLERS = new InjectionToken('ADDON_ACTION_HANDLERS');
+const ADDON_ACTION_REGISTRY = new InjectionToken('ADDON_ACTION_REGISTRY');
+function createAddonActionRegistry() {
+    const sources = inject(ADDON_ACTION_HANDLERS, { optional: true }) ?? [];
+    const map = new Map();
+    for (const handlers of sources) {
+        for (const [name, fn] of Object.entries(handlers)) {
+            map.set(name, fn);
+        }
+    }
+    return map;
+}
 
 const DF_FIELD_TEMPLATES = new InjectionToken('DF_FIELD_TEMPLATES');
 
-const FIELD_REGISTRY = new InjectionToken('FIELD_REGISTRY', {
-    providedIn: 'root',
-    factory: () => new Map(),
-});
-function getFieldValueHandling(fieldType, registry) {
-    const definition = registry.get(fieldType);
-    return definition?.valueHandling ?? 'include';
-}
-
 function isWrapperTypeDefinition(value) {
     return typeof value === 'object' && value !== null && 'wrapperName' in value;
 }
@@ -3065,19 +3317,6 @@ function dynamicTextToObservable(value, injector) {
     return of(String(value));
 }
 
-function resolveDynamicValue(value, fallback, injector) {
-    if (value === undefined) {
-        return computed(() => fallback);
-    }
-    if (isSignal(value)) {
-        return value;
-    }
-    if (isObservable(value)) {
-        return toSignal(value, { initialValue: fallback, injector });
-    }
-        return computed(() => value);
-}
-
 const INITIALIZATION_TIMEOUT_MS = new InjectionToken('INITIALIZATION_TIMEOUT_MS', {
     providedIn: 'root',
     factory: () => 10_000,
@@ -3370,5 +3609,5 @@ function createWarningTracker() {
 
 
 
-export { ADDON_KIND_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, Evaluator, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, Parser, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, Tokenizer, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyHiddenLogic, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAsyncConditionLogicFunction, createDebouncedLogicFunction, createDebouncedResourceLogicFn, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createHttpConditionLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateHttpValidationResponse, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectFieldSignalContext, interpolateParams, isArrayField, isCheckedField, isContainerField, isContainerTypedField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, safeReadPathKeys, setupInitializationTracking, shouldLog, stableStringify, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
+export { ADDON_ACTION_HANDLERS, ADDON_ACTION_REGISTRY, ADDON_TYPE_COMPONENT_CACHE, ADDON_TYPE_DEFINITIONS, ADDON_TYPE_REGISTRY, ARRAY_CONTEXT, AsyncConditionFunctionCacheService, ComponentInitializedEvent, DEFAULT_PROPS, DEFAULT_VALIDATION_MESSAGES, DEFAULT_WRAPPERS, DEPRECATION_WARNING_TRACKER, DF_FIELD_TEMPLATES, DfAddonSlot, DynamicFormError, DynamicFormLogger, DynamicTextPipe, DynamicValueFunctionCacheService, EMIT_FORM_VALUE_ON_EVENTS, EXTERNAL_DATA, Evaluator, EventBus, ExpressionParser, ExpressionParserError, FIELD_REGISTRY, FIELD_SIGNAL_CONTEXT, FORM_ID_PREFIX, FORM_OPTIONS, FieldContextRegistryService, FunctionRegistryService, GROUP_CONTEXT, HTTP_CONDITION_CACHE, HttpConditionCache, HttpConditionFunctionCacheService, INITIALIZATION_TIMEOUT_MS, LogicFunctionCacheService, NoopLogger, Parser, READONLY_FIELD_TREE_CACHE, RootFormRegistryService, TokenType, Tokenizer, WRAPPER_AUTO_ASSOCIATIONS, WRAPPER_COMPONENT_CACHE, WRAPPER_REGISTRY, applyHiddenLogic, applyMetaToElement, applyValidator, applyValidators, arrayFieldMapper, assertNever, baseFieldMapper, buildBaseInputs, buildClassName, compareValues, containerFieldMapper, createAddonActionRegistry, createAsyncConditionLogicFunction, createDebouncedLogicFunction, createDebouncedResourceLogicFn, createDefaultDerivationLogConfig, createDynamicValueFunction, createFormFieldStateMap, createHttpConditionLogicFunction, createInitializationTracker, createLogicFunction, createWarningTracker, deepMergeDefaults, derivedFromDeferred, detectFormMode, dynamicTextToObservable, evaluateCondition, evaluateHttpValidationResponse, evaluateNonFieldDisabled, evaluateNonFieldHidden, extractExpressionDependencies, extractStringDependencies, getArrayLength, getChangedKeys, getFieldValueHandling, getGridClassString, getNestedValue, groupFieldMapper, hasChildFields, hasCrossFieldWhenCondition, hasFormValue, hasNestedProperty, hasTargetProperty, injectAddonTypeRegistry, injectFieldSignalContext, injectFieldsSupportingAddons, interpolateParams, isArrayField, isCheckedField, isContainerField, isCrossFieldBuiltInValidator, isCrossFieldExpression, isCrossFieldSchema, isCrossFieldStateLogic, isCrossFieldValidator, isDerivationLogicConfig, isDisplayOnlyField, isEqual, isFieldBoundContext, isFormStateCondition, isFunctionHttpValidator, isGenericContainerField, isGroupField, isHiddenField, isLeafField, isNonPagedForm, isPageField, isPagedForm, isResourceBasedValidator, isRowField, isSimplifiedArrayField, isStateLogicConfig, isValidNonPagedForm, isValidPagedForm, isValueBearingField, isValueField, isWrapperTypeDefinition, keyBy, mapValues, memoize, normalizeFieldsArray, omit, pageFieldMapper, readFieldStateInfo, resolveDynamicValue, resolveHttpRequest, resolveNextButtonDisabled, resolveNonFieldDisabled, resolveNonFieldHidden, resolveSubmitButtonDisabled, resolveTokens, rowFieldMapper, runPresetAction, safeReadPathKeys, setupInitializationTracking, shouldLog, stableStringify, textFieldMapper, toReadonlyFieldTree, toReadonlyFieldTreeCached, validatePageNesting, withPreviousValue, writeToFieldValue };
 //# sourceMappingURL=ng-forge-dynamic-forms-internal.mjs.map