@ngx-formly/core 6.3.10 → 7.0.0-alpha.0

package/esm2022/lib/services/formly.config.mjs

@@ -0,0 +1,229 @@
+import { Injectable, Type } from '@angular/core';
+import { reverseDeepMerge, defineHiddenProp } from './../utils';
+import * as i0 from "@angular/core";
+/**
+ * Maintains list of formly config options. This can be used to register new field type.
+ */
+export class FormlyConfig {
+    constructor() {
+        this.types = {};
+        this.validators = {};
+        this.wrappers = {};
+        this.messages = {};
+        this.extras = {
+            checkExpressionOn: 'modelChange',
+            lazyRender: true,
+            resetFieldOnHide: true,
+            renderFormlyFieldElement: true,
+            showError(field) {
+                return (field.formControl?.invalid &&
+                    (field.formControl?.touched || field.options.parentForm?.submitted || !!field.field.validation?.show));
+            },
+        };
+        this.extensions = {};
+        this.presets = {};
+        this.extensionsByPriority = {};
+    }
+    addConfig(config) {
+        if (Array.isArray(config)) {
+            config.forEach((c) => this.addConfig(c));
+            return;
+        }
+        if (config.types) {
+            config.types.forEach((type) => this.setType(type));
+        }
+        if (config.validators) {
+            config.validators.forEach((validator) => this.setValidator(validator));
+        }
+        if (config.wrappers) {
+            config.wrappers.forEach((wrapper) => this.setWrapper(wrapper));
+        }
+        if (config.validationMessages) {
+            config.validationMessages.forEach((validation) => this.addValidatorMessage(validation.name, validation.message));
+        }
+        if (config.extensions) {
+            this.setSortedExtensions(config.extensions);
+        }
+        if (config.extras) {
+            this.extras = { ...this.extras, ...config.extras };
+        }
+        if (config.presets) {
+            this.presets = {
+                ...this.presets,
+                ...config.presets.reduce((acc, curr) => ({ ...acc, [curr.name]: curr.config }), {}),
+            };
+        }
+    }
+    /**
+     * Allows you to specify a custom type which you can use in your field configuration.
+     * You can pass an object of options, or an array of objects of options.
+     */
+    setType(options) {
+        if (Array.isArray(options)) {
+            options.forEach((option) => this.setType(option));
+        }
+        else {
+            if (!this.types[options.name]) {
+                this.types[options.name] = { name: options.name };
+            }
+            ['component', 'extends', 'defaultOptions', 'wrappers'].forEach((prop) => {
+                if (options.hasOwnProperty(prop)) {
+                    this.types[options.name][prop] = options[prop];
+                }
+            });
+        }
+    }
+    getType(name, throwIfNotFound = false) {
+        if (name instanceof Type) {
+            return { component: name, name: name.prototype.constructor.name };
+        }
+        if (!this.types[name]) {
+            if (throwIfNotFound) {
+                throw new Error(`[Formly Error] The type "${name}" could not be found. Please make sure that is registered through the FormlyModule declaration.`);
+            }
+            return null;
+        }
+        this.mergeExtendedType(name);
+        return this.types[name];
+    }
+    /** @ignore */
+    getMergedField(field = {}) {
+        const type = this.getType(field.type);
+        if (!type) {
+            return;
+        }
+        if (type.defaultOptions) {
+            reverseDeepMerge(field, type.defaultOptions);
+        }
+        const extendDefaults = type.extends && this.getType(type.extends).defaultOptions;
+        if (extendDefaults) {
+            reverseDeepMerge(field, extendDefaults);
+        }
+        if (field?.optionsTypes) {
+            field.optionsTypes.forEach((option) => {
+                const defaultOptions = this.getType(option).defaultOptions;
+                if (defaultOptions) {
+                    reverseDeepMerge(field, defaultOptions);
+                }
+            });
+        }
+        const componentRef = this.resolveFieldTypeRef(field);
+        if (componentRef?.instance?.defaultOptions) {
+            reverseDeepMerge(field, componentRef.instance.defaultOptions);
+        }
+        if (!field.wrappers && type.wrappers) {
+            field.wrappers = [...type.wrappers];
+        }
+    }
+    /** @ignore @internal */
+    resolveFieldTypeRef(field = {}) {
+        const type = this.getType(field.type);
+        if (!type) {
+            return null;
+        }
+        if (!type.component || type._componentRef) {
+            return type._componentRef;
+        }
+        const { _viewContainerRef, _injector } = field.options;
+        if (!_viewContainerRef || !_injector) {
+            return null;
+        }
+        const componentRef = _viewContainerRef.createComponent(type.component, { injector: _injector });
+        defineHiddenProp(type, '_componentRef', componentRef);
+        try {
+            componentRef.destroy();
+        }
+        catch (e) {
+            console.error(`An error occurred while destroying the Formly component type "${field.type}"`, e);
+        }
+        return type._componentRef;
+    }
+    setWrapper(options) {
+        this.wrappers[options.name] = options;
+        if (options.types) {
+            options.types.forEach((type) => {
+                this.setTypeWrapper(type, options.name);
+            });
+        }
+    }
+    getWrapper(name) {
+        if (name instanceof Type) {
+            return { component: name, name: name.prototype.constructor.name };
+        }
+        if (!this.wrappers[name]) {
+            throw new Error(`[Formly Error] The wrapper "${name}" could not be found. Please make sure that is registered through the FormlyModule declaration.`);
+        }
+        return this.wrappers[name];
+    }
+    /** @ignore */
+    setTypeWrapper(type, name) {
+        if (!this.types[type]) {
+            this.types[type] = {};
+        }
+        if (!this.types[type].wrappers) {
+            this.types[type].wrappers = [];
+        }
+        if (this.types[type].wrappers.indexOf(name) === -1) {
+            this.types[type].wrappers.push(name);
+        }
+    }
+    setValidator(options) {
+        this.validators[options.name] = options;
+    }
+    getValidator(name) {
+        if (!this.validators[name]) {
+            throw new Error(`[Formly Error] The validator "${name}" could not be found. Please make sure that is registered through the FormlyModule declaration.`);
+        }
+        return this.validators[name];
+    }
+    addValidatorMessage(name, message) {
+        this.messages[name] = message;
+        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+            const deprecated = { minlength: 'minLength', maxlength: 'maxLength' };
+            if (deprecated[name]) {
+                console.warn(`Formly deprecation: passing validation messages key '${name}' is deprecated since v6.0, use '${deprecated[name]}' instead.`);
+                this.messages[deprecated[name]] = message;
+            }
+        }
+    }
+    getValidatorMessage(name) {
+        return this.messages[name];
+    }
+    setSortedExtensions(extensionOptions) {
+        // insert new extensions, grouped by priority
+        extensionOptions.forEach((extensionOption) => {
+            const priority = extensionOption.priority ?? 1;
+            this.extensionsByPriority[priority] = {
+                ...this.extensionsByPriority[priority],
+                [extensionOption.name]: extensionOption.extension,
+            };
+        });
+        // flatten extensions object with sorted keys
+        this.extensions = Object.keys(this.extensionsByPriority)
+            .map(Number)
+            .sort((a, b) => a - b)
+            .reduce((acc, prio) => ({
+            ...acc,
+            ...this.extensionsByPriority[prio],
+        }), {});
+    }
+    mergeExtendedType(name) {
+        if (!this.types[name].extends) {
+            return;
+        }
+        const extendedType = this.getType(this.types[name].extends);
+        if (!this.types[name].component) {
+            this.types[name].component = extendedType.component;
+        }
+        if (!this.types[name].wrappers) {
+            this.types[name].wrappers = extendedType.wrappers;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formly.config.js","sourceRoot":"","sources":["../../../../../../src/core/src/lib/services/formly.config.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, ComponentRef, Type } from '@angular/core';\nimport { FieldType } from './../templates/field.type';\nimport { reverseDeepMerge, defineHiddenProp } from './../utils';\nimport {\n  FormlyFieldConfig,\n  FormlyFieldConfigCache,\n  ConfigOption,\n  TypeOption,\n  ValidatorOption,\n  WrapperOption,\n  FormlyExtension,\n  ValidationMessageOption,\n  ExtensionOption,\n  FormlyFieldConfigPresetProvider,\n} from '../models';\nimport { FieldWrapper } from '../templates/field.wrapper';\n\ndeclare const ngDevMode: any;\n\n/**\n * Maintains list of formly config options. This can be used to register new field type.\n */\n@Injectable({ providedIn: 'root' })\nexport class FormlyConfig {\n  types: { [name: string]: TypeOption } = {};\n  validators: { [name: string]: ValidatorOption } = {};\n  wrappers: { [name: string]: WrapperOption } = {};\n  messages: { [name: string]: ValidationMessageOption['message'] } = {};\n\n  extras: NonNullable<ConfigOption['extras']> = {\n    checkExpressionOn: 'modelChange',\n    lazyRender: true,\n    resetFieldOnHide: true,\n    renderFormlyFieldElement: true,\n    showError(field: FieldType) {\n      return (\n        field.formControl?.invalid &&\n        (field.formControl?.touched || field.options.parentForm?.submitted || !!field.field.validation?.show)\n      );\n    },\n  };\n  extensions: { [name: string]: FormlyExtension } = {};\n  presets: { [name: string]: FormlyFieldConfig | FormlyFieldConfigPresetProvider } = {};\n\n  private extensionsByPriority: Record<number, { [name: string]: FormlyExtension }> = {};\n\n  addConfig(config: ConfigOption | ConfigOption[]) {\n    if (Array.isArray(config)) {\n      config.forEach((c) => this.addConfig(c));\n      return;\n    }\n\n    if (config.types) {\n      config.types.forEach((type) => this.setType(type));\n    }\n    if (config.validators) {\n      config.validators.forEach((validator) => this.setValidator(validator));\n    }\n    if (config.wrappers) {\n      config.wrappers.forEach((wrapper) => this.setWrapper(wrapper));\n    }\n    if (config.validationMessages) {\n      config.validationMessages.forEach((validation) => this.addValidatorMessage(validation.name, validation.message));\n    }\n    if (config.extensions) {\n      this.setSortedExtensions(config.extensions);\n    }\n    if (config.extras) {\n      this.extras = { ...this.extras, ...config.extras };\n    }\n    if (config.presets) {\n      this.presets = {\n        ...this.presets,\n        ...config.presets.reduce((acc, curr) => ({ ...acc, [curr.name]: curr.config }), {}),\n      };\n    }\n  }\n\n  /**\n   * Allows you to specify a custom type which you can use in your field configuration.\n   * You can pass an object of options, or an array of objects of options.\n   */\n  setType(options: TypeOption | TypeOption[]) {\n    if (Array.isArray(options)) {\n      options.forEach((option) => this.setType(option));\n    } else {\n      if (!this.types[options.name]) {\n        this.types[options.name] = <TypeOption>{ name: options.name };\n      }\n\n      (['component', 'extends', 'defaultOptions', 'wrappers'] as (keyof TypeOption)[]).forEach((prop) => {\n        if (options.hasOwnProperty(prop)) {\n          this.types[options.name][prop] = options[prop] as any;\n        }\n      });\n    }\n  }\n\n  getType(name: FormlyFieldConfig['type'], throwIfNotFound = false): TypeOption {\n    if (name instanceof Type) {\n      return { component: name, name: name.prototype.constructor.name };\n    }\n\n    if (!this.types[name]) {\n      if (throwIfNotFound) {\n        throw new Error(\n          `[Formly Error] The type \"${name}\" could not be found. Please make sure that is registered through the FormlyModule declaration.`,\n        );\n      }\n\n      return null;\n    }\n\n    this.mergeExtendedType(name);\n\n    return this.types[name];\n  }\n\n  /** @ignore */\n  getMergedField(field: FormlyFieldConfig = {}): any {\n    const type = this.getType(field.type);\n    if (!type) {\n      return;\n    }\n\n    if (type.defaultOptions) {\n      reverseDeepMerge(field, type.defaultOptions);\n    }\n\n    const extendDefaults = type.extends && this.getType(type.extends).defaultOptions;\n    if (extendDefaults) {\n      reverseDeepMerge(field, extendDefaults);\n    }\n\n    if (field?.optionsTypes) {\n      field.optionsTypes.forEach((option) => {\n        const defaultOptions = this.getType(option).defaultOptions;\n        if (defaultOptions) {\n          reverseDeepMerge(field, defaultOptions);\n        }\n      });\n    }\n\n    const componentRef = this.resolveFieldTypeRef(field);\n    if (componentRef?.instance?.defaultOptions) {\n      reverseDeepMerge(field, componentRef.instance.defaultOptions);\n    }\n\n    if (!field.wrappers && type.wrappers) {\n      field.wrappers = [...type.wrappers];\n    }\n  }\n\n  /** @ignore @internal */\n  resolveFieldTypeRef(field: FormlyFieldConfigCache = {}): ComponentRef<FieldType> {\n    const type: TypeOption & { _componentRef?: ComponentRef<any> } = this.getType(field.type);\n    if (!type) {\n      return null;\n    }\n\n    if (!type.component || type._componentRef) {\n      return type._componentRef;\n    }\n\n    const { _viewContainerRef, _injector } = field.options;\n    if (!_viewContainerRef || !_injector) {\n      return null;\n    }\n\n    const componentRef = _viewContainerRef.createComponent<FieldType>(type.component, { injector: _injector });\n    defineHiddenProp(type, '_componentRef', componentRef);\n    try {\n      componentRef.destroy();\n    } catch (e) {\n      console.error(`An error occurred while destroying the Formly component type \"${field.type}\"`, e);\n    }\n\n    return type._componentRef;\n  }\n\n  setWrapper(options: WrapperOption) {\n    this.wrappers[options.name] = options;\n    if (options.types) {\n      options.types.forEach((type) => {\n        this.setTypeWrapper(type, options.name);\n      });\n    }\n  }\n\n  getWrapper(name: string | Type<FieldWrapper>): WrapperOption {\n    if (name instanceof Type) {\n      return { component: name, name: name.prototype.constructor.name };\n    }\n\n    if (!this.wrappers[name]) {\n      throw new Error(\n        `[Formly Error] The wrapper \"${name}\" could not be found. Please make sure that is registered through the FormlyModule declaration.`,\n      );\n    }\n\n    return this.wrappers[name];\n  }\n\n  /** @ignore */\n  setTypeWrapper(type: string, name: string) {\n    if (!this.types[type]) {\n      this.types[type] = <TypeOption>{};\n    }\n    if (!this.types[type].wrappers) {\n      this.types[type].wrappers = [];\n    }\n    if (this.types[type].wrappers.indexOf(name) === -1) {\n      this.types[type].wrappers.push(name);\n    }\n  }\n\n  setValidator(options: ValidatorOption) {\n    this.validators[options.name] = options;\n  }\n\n  getValidator(name: string): ValidatorOption {\n    if (!this.validators[name]) {\n      throw new Error(\n        `[Formly Error] The validator \"${name}\" could not be found. Please make sure that is registered through the FormlyModule declaration.`,\n      );\n    }\n\n    return this.validators[name];\n  }\n\n  addValidatorMessage(name: string, message: ValidationMessageOption['message']) {\n    this.messages[name] = message;\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const deprecated = { minlength: 'minLength', maxlength: 'maxLength' } as any;\n      if (deprecated[name]) {\n        console.warn(\n          `Formly deprecation: passing validation messages key '${name}' is deprecated since v6.0, use '${deprecated[name]}' instead.`,\n        );\n        this.messages[deprecated[name]] = message;\n      }\n    }\n  }\n\n  getValidatorMessage(name: string) {\n    return this.messages[name];\n  }\n\n  private setSortedExtensions(extensionOptions: ExtensionOption[]) {\n    // insert new extensions, grouped by priority\n    extensionOptions.forEach((extensionOption) => {\n      const priority = extensionOption.priority ?? 1;\n      this.extensionsByPriority[priority] = {\n        ...this.extensionsByPriority[priority],\n        [extensionOption.name]: extensionOption.extension,\n      };\n    });\n    // flatten extensions object with sorted keys\n    this.extensions = Object.keys(this.extensionsByPriority)\n      .map(Number)\n      .sort((a, b) => a - b)\n      .reduce(\n        (acc, prio) => ({\n          ...acc,\n          ...this.extensionsByPriority[prio],\n        }),\n        {},\n      );\n  }\n\n  private mergeExtendedType(name: string) {\n    if (!this.types[name].extends) {\n      return;\n    }\n\n    const extendedType = this.getType(this.types[name].extends);\n    if (!this.types[name].component) {\n      this.types[name].component = extendedType.component;\n    }\n\n    if (!this.types[name].wrappers) {\n      this.types[name].wrappers = extendedType.wrappers;\n    }\n  }\n}\n"]}

package/esm2022/lib/templates/field-array.type.mjs

@@ -0,0 +1,84 @@
+import { Directive } from '@angular/core';
+import { UntypedFormArray } from '@angular/forms';
+import { FieldType } from './field.type';
+import { clone, assignFieldValue, getFieldValue, hasKey } from '../utils';
+import { registerControl, unregisterControl, findControl } from '../extensions/field-form/utils';
+import * as i0 from "@angular/core";
+export class FieldArrayType extends FieldType {
+    onPopulate(field) {
+        if (hasKey(field)) {
+            const control = findControl(field);
+            registerControl(field, control ? control : new UntypedFormArray([], { updateOn: field.modelOptions.updateOn }));
+        }
+        field.fieldGroup = field.fieldGroup || [];
+        const length = Array.isArray(field.model) ? field.model.length : 0;
+        if (field.fieldGroup.length > length) {
+            for (let i = field.fieldGroup.length - 1; i >= length; --i) {
+                unregisterControl(field.fieldGroup[i], true);
+                field.fieldGroup.splice(i, 1);
+            }
+        }
+        for (let i = field.fieldGroup.length; i < length; i++) {
+            const f = { ...clone(typeof field.fieldArray === 'function' ? field.fieldArray(field) : field.fieldArray) };
+            if (f.key !== null) {
+                f.key = `${i}`;
+            }
+            field.fieldGroup.push(f);
+        }
+    }
+    add(i, initialModel, { markAsDirty } = { markAsDirty: true }) {
+        markAsDirty && this.formControl.markAsDirty();
+        i = i == null ? this.field.fieldGroup.length : i;
+        if (!this.model) {
+            assignFieldValue(this.field, []);
+        }
+        this.model.splice(i, 0, initialModel ? clone(initialModel) : undefined);
+        this.markFieldForCheck(this.field.fieldGroup[i]);
+        this._build();
+    }
+    remove(i, { markAsDirty } = { markAsDirty: true }) {
+        markAsDirty && this.formControl.markAsDirty();
+        this.model.splice(i, 1);
+        const field = this.field.fieldGroup[i];
+        this.field.fieldGroup.splice(i, 1);
+        this.field.fieldGroup.forEach((f, key) => this.updateArrayElementKey(f, `${key}`));
+        unregisterControl(field, true);
+        this._build();
+    }
+    _build() {
+        const fields = this.field.formControl._fields ?? [this.field];
+        fields.forEach((f) => this.options.build(f));
+        this.options.fieldChanges.next({
+            field: this.field,
+            value: getFieldValue(this.field),
+            type: 'valueChanges',
+        });
+    }
+    updateArrayElementKey(f, newKey) {
+        if (hasKey(f)) {
+            f.key = newKey;
+            return;
+        }
+        if (!f.fieldGroup?.length) {
+            return;
+        }
+        for (let i = 0; i < f.fieldGroup.length; i++) {
+            this.updateArrayElementKey(f.fieldGroup[i], newKey);
+        }
+    }
+    markFieldForCheck(f) {
+        if (!f) {
+            return;
+        }
+        f.fieldGroup?.forEach((c) => this.markFieldForCheck(c));
+        if (f.hide === false) {
+            this.options._hiddenFieldsForCheck.push({ field: f });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FieldArrayType, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FieldArrayType, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FieldArrayType, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"field-array.type.js","sourceRoot":"","sources":["../../../../../../src/core/src/lib/templates/field-array.type.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive } from '@angular/core';\nimport { UntypedFormArray } from '@angular/forms';\nimport { FieldType } from './field.type';\nimport { clone, assignFieldValue, getFieldValue, hasKey } from '../utils';\nimport { FormlyFieldConfig, FormlyExtension, FormlyFieldConfigCache } from '../models';\nimport { registerControl, unregisterControl, findControl } from '../extensions/field-form/utils';\n\nexport interface FieldArrayTypeConfig<T = FormlyFieldConfig['props']> extends FormlyFieldConfig<T> {\n  formControl: UntypedFormArray;\n  props: NonNullable<T>;\n}\n\n@Directive()\nexport abstract class FieldArrayType<F extends FormlyFieldConfig = FieldArrayTypeConfig>\n  extends FieldType<F>\n  implements FormlyExtension<F>\n{\n  onPopulate(field: F) {\n    if (hasKey(field)) {\n      const control = findControl(field);\n      registerControl(field, control ? control : new UntypedFormArray([], { updateOn: field.modelOptions.updateOn }));\n    }\n\n    field.fieldGroup = field.fieldGroup || [];\n\n    const length = Array.isArray(field.model) ? field.model.length : 0;\n    if (field.fieldGroup.length > length) {\n      for (let i = field.fieldGroup.length - 1; i >= length; --i) {\n        unregisterControl(field.fieldGroup[i], true);\n        field.fieldGroup.splice(i, 1);\n      }\n    }\n\n    for (let i = field.fieldGroup.length; i < length; i++) {\n      const f = { ...clone(typeof field.fieldArray === 'function' ? field.fieldArray(field) : field.fieldArray) };\n      if (f.key !== null) {\n        f.key = `${i}`;\n      }\n\n      field.fieldGroup.push(f);\n    }\n  }\n\n  add(i?: number, initialModel?: any, { markAsDirty } = { markAsDirty: true }) {\n    markAsDirty && this.formControl.markAsDirty();\n    i = i == null ? this.field.fieldGroup.length : i;\n    if (!this.model) {\n      assignFieldValue(this.field, []);\n    }\n\n    this.model.splice(i, 0, initialModel ? clone(initialModel) : undefined);\n    this.markFieldForCheck(this.field.fieldGroup[i]);\n    this._build();\n  }\n\n  remove(i: number, { markAsDirty } = { markAsDirty: true }) {\n    markAsDirty && this.formControl.markAsDirty();\n    this.model.splice(i, 1);\n\n    const field = this.field.fieldGroup[i];\n    this.field.fieldGroup.splice(i, 1);\n    this.field.fieldGroup.forEach((f, key) => this.updateArrayElementKey(f, `${key}`));\n    unregisterControl(field, true);\n    this._build();\n  }\n\n  private _build() {\n    const fields = (this.field as FormlyFieldConfigCache).formControl._fields ?? [this.field];\n    fields.forEach((f) => (this.options as any).build(f));\n    this.options.fieldChanges.next({\n      field: this.field,\n      value: getFieldValue(this.field),\n      type: 'valueChanges',\n    });\n  }\n\n  private updateArrayElementKey(f: FormlyFieldConfig, newKey: string) {\n    if (hasKey(f)) {\n      f.key = newKey;\n      return;\n    }\n\n    if (!f.fieldGroup?.length) {\n      return;\n    }\n\n    for (let i = 0; i < f.fieldGroup.length; i++) {\n      this.updateArrayElementKey(f.fieldGroup[i], newKey);\n    }\n  }\n\n  private markFieldForCheck(f: FormlyFieldConfig) {\n    if (!f) {\n      return;\n    }\n\n    f.fieldGroup?.forEach((c: any) => this.markFieldForCheck(c));\n    if (f.hide === false) {\n      (this.options as FormlyFieldConfigCache['options'])._hiddenFieldsForCheck.push({ field: f });\n    }\n  }\n}\n"]}

package/{esm2020 → esm2022}/lib/templates/field-template.type.mjs

@@ -4,11 +4,6 @@ import * as i0 from "@angular/core";
 import * as i1 from "@angular/platform-browser";
 /** @ignore */
 export class FormlyTemplateType extends FieldType {
-    constructor(sanitizer) {
-        super();
-        this.sanitizer = sanitizer;
-        this.innerHtml = {};
-    }
     get template() {
         if (this.field && this.field.template !== this.innerHtml.template) {
             this.innerHtml = {
@@ -20,10 +15,15 @@ export class FormlyTemplateType extends FieldType {
         }
         return this.innerHtml.content;
     }
+    constructor(sanitizer) {
+        super();
+        this.sanitizer = sanitizer;
+        this.innerHtml = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyTemplateType, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: FormlyTemplateType, selector: "formly-template", usesInheritance: true, ngImport: i0, template: `<div [innerHtml]="template"></div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
 }
-FormlyTemplateType.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyTemplateType, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
-FormlyTemplateType.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: FormlyTemplateType, selector: "formly-template", usesInheritance: true, ngImport: i0, template: `<div [innerHtml]="template"></div>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FormlyTemplateType, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FormlyTemplateType, decorators: [{
             type: Component,
             args: [{
                     selector: 'formly-template',
@@ -31,4 +31,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
                     changeDetection: ChangeDetectionStrategy.OnPush,
                 }]
         }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/templates/field.type.mjs

@@ -0,0 +1,57 @@
+import { Input, Directive, ViewChildren } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class FieldType {
+    constructor() {
+        this.field = {};
+    }
+    set _formlyControls(controls) {
+        const f = this.field;
+        f._localFields = controls
+            .map((c) => c.control._fields || [])
+            .flat()
+            .filter((f) => f.formControl !== this.field.formControl);
+    }
+    get model() {
+        return this.field.model;
+    }
+    get form() {
+        return this.field.form;
+    }
+    get options() {
+        return this.field.options;
+    }
+    get key() {
+        return this.field.key;
+    }
+    get formControl() {
+        return this.field.formControl;
+    }
+    get props() {
+        return (this.field.props || {});
+    }
+    /** @deprecated Use `props` instead. */
+    get to() {
+        return this.props;
+    }
+    get showError() {
+        return this.options.showError(this);
+    }
+    get id() {
+        return this.field.id;
+    }
+    get formState() {
+        return this.options?.formState || {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FieldType, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FieldType, inputs: { field: "field" }, viewQueries: [{ propertyName: "_formlyControls", predicate: NgControl, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FieldType, decorators: [{
+            type: Directive
+        }], propDecorators: { _formlyControls: [{
+                type: ViewChildren,
+                args: [NgControl]
+            }], field: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/templates/field.wrapper.mjs

@@ -6,10 +6,10 @@ export class FieldWrapper extends FieldType {
     set _staticContent(content) {
         this.fieldComponent = content;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: FieldWrapper, viewQueries: [{ propertyName: "fieldComponent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef }, { propertyName: "_staticContent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0 }); }
 }
-FieldWrapper.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FieldWrapper, deps: null, target: i0.ɵɵFactoryTarget.Directive });
-FieldWrapper.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.12", type: FieldWrapper, viewQueries: [{ propertyName: "fieldComponent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef }, { propertyName: "_staticContent", first: true, predicate: ["fieldComponent"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: FieldWrapper, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: FieldWrapper, decorators: [{
             type: Directive
         }], propDecorators: { fieldComponent: [{
                 type: ViewChild,
@@ -18,4 +18,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
                 type: ViewChild,
                 args: ['fieldComponent', { read: ViewContainerRef, static: true }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQud3JhcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3NyYy9saWIvdGVtcGxhdGVzL2ZpZWxkLndyYXBwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQWEsTUFBTSxlQUFlLENBQUM7QUFDbEYsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGNBQWMsQ0FBQzs7QUFLekMsTUFBTSxPQUFnQixZQUE4RCxTQUFRLFNBQVk7SUFDdEcsSUFBYSxlQUFlLENBQUMsQ0FBdUIsSUFBRyxDQUFDO0lBRXhELElBQTJFLGNBQWMsQ0FBQyxPQUF5QjtRQUNqSCxJQUFJLENBQUMsY0FBYyxHQUFHLE9BQU8sQ0FBQztJQUNoQyxDQUFDOzswR0FMbUIsWUFBWTs4RkFBWixZQUFZLHVIQUVLLGdCQUFnQiwyR0FDaEIsZ0JBQWdCOzRGQUhqQyxZQUFZO2tCQURqQyxTQUFTOzhCQUdpRCxjQUFjO3NCQUF0RSxTQUFTO3VCQUFDLGdCQUFnQixFQUFFLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFO2dCQUNvQixjQUFjO3NCQUF4RixTQUFTO3VCQUFDLGdCQUFnQixFQUFFLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWaWV3Q29udGFpbmVyUmVmLCBWaWV3Q2hpbGQsIERpcmVjdGl2ZSwgUXVlcnlMaXN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGaWVsZFR5cGUgfSBmcm9tICcuL2ZpZWxkLnR5cGUnO1xuaW1wb3J0IHsgRm9ybWx5RmllbGRDb25maWcgfSBmcm9tICcuLi9tb2RlbHMnO1xuaW1wb3J0IHsgTmdDb250cm9sIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGaWVsZFdyYXBwZXI8RiBleHRlbmRzIEZvcm1seUZpZWxkQ29uZmlnID0gRm9ybWx5RmllbGRDb25maWc+IGV4dGVuZHMgRmllbGRUeXBlPEY+IHtcbiAgb3ZlcnJpZGUgc2V0IF9mb3JtbHlDb250cm9scyhfOiBRdWVyeUxpc3Q8TmdDb250cm9sPikge31cbiAgQFZpZXdDaGlsZCgnZmllbGRDb21wb25lbnQnLCB7IHJlYWQ6IFZpZXdDb250YWluZXJSZWYgfSkgZmllbGRDb21wb25lbnQhOiBWaWV3Q29udGFpbmVyUmVmO1xuICBAVmlld0NoaWxkKCdmaWVsZENvbXBvbmVudCcsIHsgcmVhZDogVmlld0NvbnRhaW5lclJlZiwgc3RhdGljOiB0cnVlIH0pIHNldCBfc3RhdGljQ29udGVudChjb250ZW50OiBWaWV3Q29udGFpbmVyUmVmKSB7XG4gICAgdGhpcy5maWVsZENvbXBvbmVudCA9IGNvbnRlbnQ7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQud3JhcHBlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9jb3JlL3NyYy9saWIvdGVtcGxhdGVzL2ZpZWxkLndyYXBwZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxTQUFTLEVBQWEsTUFBTSxlQUFlLENBQUM7QUFDbEYsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGNBQWMsQ0FBQzs7QUFLekMsTUFBTSxPQUFnQixZQUE4RCxTQUFRLFNBQVk7SUFDdEcsSUFBYSxlQUFlLENBQUMsQ0FBdUIsSUFBRyxDQUFDO0lBRXhELElBQTJFLGNBQWMsQ0FBQyxPQUF5QjtRQUNqSCxJQUFJLENBQUMsY0FBYyxHQUFHLE9BQU8sQ0FBQztJQUNoQyxDQUFDOytHQUxtQixZQUFZO21HQUFaLFlBQVksdUhBRUssZ0JBQWdCLDJHQUNoQixnQkFBZ0I7OzRGQUhqQyxZQUFZO2tCQURqQyxTQUFTOzhCQUdpRCxjQUFjO3NCQUF0RSxTQUFTO3VCQUFDLGdCQUFnQixFQUFFLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFO2dCQUNvQixjQUFjO3NCQUF4RixTQUFTO3VCQUFDLGdCQUFnQixFQUFFLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBWaWV3Q29udGFpbmVyUmVmLCBWaWV3Q2hpbGQsIERpcmVjdGl2ZSwgUXVlcnlMaXN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGaWVsZFR5cGUgfSBmcm9tICcuL2ZpZWxkLnR5cGUnO1xuaW1wb3J0IHsgRm9ybWx5RmllbGRDb25maWcgfSBmcm9tICcuLi9tb2RlbHMnO1xuaW1wb3J0IHsgTmdDb250cm9sIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuXG5ARGlyZWN0aXZlKClcbmV4cG9ydCBhYnN0cmFjdCBjbGFzcyBGaWVsZFdyYXBwZXI8RiBleHRlbmRzIEZvcm1seUZpZWxkQ29uZmlnID0gRm9ybWx5RmllbGRDb25maWc+IGV4dGVuZHMgRmllbGRUeXBlPEY+IHtcbiAgb3ZlcnJpZGUgc2V0IF9mb3JtbHlDb250cm9scyhfOiBRdWVyeUxpc3Q8TmdDb250cm9sPikge31cbiAgQFZpZXdDaGlsZCgnZmllbGRDb21wb25lbnQnLCB7IHJlYWQ6IFZpZXdDb250YWluZXJSZWYgfSkgZmllbGRDb21wb25lbnQhOiBWaWV3Q29udGFpbmVyUmVmO1xuICBAVmlld0NoaWxkKCdmaWVsZENvbXBvbmVudCcsIHsgcmVhZDogVmlld0NvbnRhaW5lclJlZiwgc3RhdGljOiB0cnVlIH0pIHNldCBfc3RhdGljQ29udGVudChjb250ZW50OiBWaWV3Q29udGFpbmVyUmVmKSB7XG4gICAgdGhpcy5maWVsZENvbXBvbmVudCA9IGNvbnRlbnQ7XG4gIH1cbn1cbiJdfQ==