@ngx-formly/core 8.0.0 → 9.0.0

package/json-schema/index.d.ts

@@ -1,5 +1,39 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngx-formly/core/json-schema" />
-export * from './public_api';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { JSONSchema7 } from 'json-schema';
+import * as i0 from '@angular/core';
+
+interface FormlyJsonschemaOptions {
+    /**
+     * allows to intercept the mapping, taking the already mapped
+     * formly field and the original JSONSchema source from which it
+     * was mapped.
+     */
+    map?: (mappedField: FormlyFieldConfig, mapSource: JSONSchema7) => FormlyFieldConfig;
+}
+declare class FormlyJsonschema {
+    toFieldConfig(schema: JSONSchema7, options?: FormlyJsonschemaOptions): FormlyFieldConfig;
+    private _toFieldConfig;
+    private resolveSchema;
+    private resolveAllOf;
+    private resolveMultiSchema;
+    private createMultiSchemaField;
+    private ensureMultiSchemaField;
+    private getSchemaField;
+    private isRecursiveMultiSchema;
+    private getDefinition;
+    private resolveDefinition;
+    private resolveDependencies;
+    private extractIfCondition;
+    private resolveIfThenElse;
+    private resolveConditionalSchema;
+    private guessSchemaType;
+    private addValidator;
+    private isEnum;
+    private toEnumOptions;
+    private isFieldValid;
+    private mergeFields;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyJsonschema, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormlyJsonschema>;
+}
+
+export { FormlyJsonschema };

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ngx-formly/core",
-  "version": "8.0.0",
+  "version": "9.0.0",
   "license": "MIT",
   "dependencies": {
     "tslib": "^2.0.0"
   },
   "peerDependencies": {
-    "@angular/forms": ">=19.0.0",
+    "@angular/forms": ">=20.0.0",
     "rxjs": "^6.5.3 || ^7.0.0"
   },
   "module": "fesm2022/ngx-formly-core.mjs",

package/preset/index.d.ts

@@ -1,5 +1,13 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngx-formly/core/preset" />
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+import * as i1 from '@ngx-formly/core';
+
+declare class FormlyPresetModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyPresetModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyPresetModule, never, [typeof i1.FormlyModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyPresetModule>;
+}
+
+declare function provideFormlyPreset(): Provider;
+
+export { FormlyPresetModule, provideFormlyPreset };

package/select/index.d.ts

@@ -1,5 +1,44 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngx-formly/core/select" />
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { PipeTransform, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FormlyFieldProps, FormlyFieldConfig } from '@ngx-formly/core';
+
+interface FormlySelectOption {
+    label: string;
+    disabled?: boolean;
+    value?: any;
+    group?: FormlySelectOption[];
+}
+interface FormlyFieldSelectProps extends FormlyFieldProps {
+    groupProp?: string | ((option: any) => string);
+    labelProp?: string | ((option: any) => string);
+    valueProp?: string | ((option: any) => any);
+    disabledProp?: string | ((option: any) => boolean);
+    mapProp?: (option: any) => FormlySelectOption;
+}
+declare class FormlySelectOptionsPipe implements PipeTransform, OnDestroy {
+    private _subscription;
+    private _options;
+    transform(options: any, field?: FormlyFieldConfig): Observable<FormlySelectOption[]>;
+    ngOnDestroy(): void;
+    private transformOptions;
+    private transformOption;
+    private transformSelectProps;
+    private dispose;
+    private observableOf;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlySelectOptionsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FormlySelectOptionsPipe, "formlySelectOptions", true>;
+}
+declare class LegacyFormlySelectOptionsPipe extends FormlySelectOptionsPipe implements PipeTransform, OnDestroy {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyFormlySelectOptionsPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LegacyFormlySelectOptionsPipe, "formlySelectOptions", false>;
+}
+
+declare class FormlySelectModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormlySelectModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlySelectModule, [typeof LegacyFormlySelectOptionsPipe], never, [typeof LegacyFormlySelectOptionsPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormlySelectModule>;
+}
+
+export { FormlySelectModule, FormlySelectOptionsPipe, LegacyFormlySelectOptionsPipe };
+export type { FormlyFieldSelectProps, FormlySelectOption };

package/testing/index.d.ts

@@ -1,5 +1,37 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngx-formly/core/testing" />
-export * from './public_api';
+import { ComponentFixture } from '@angular/core/testing';
+import { NgModule, DebugElement } from '@angular/core';
+import { ConfigOption, FormlyFieldConfig } from '@ngx-formly/core';
+
+interface IComponentOptions<T> extends NgModule {
+    template?: string;
+    inputs?: T;
+    config?: ConfigOption;
+    detectChanges?: boolean;
+}
+interface IFormlyDebugElement<E> extends DebugElement {
+    readonly nativeElement: E;
+}
+declare function createComponent<T>({ template, inputs, config, detectChanges, imports, declarations, providers, }: IComponentOptions<T>): T & {
+    fixture: ComponentFixture<T>;
+    detectChanges: (checkNoChanges?: boolean) => void;
+    setInputs: (inputs: Partial<T>) => void;
+    query: <E extends Element = Element>(selector: string) => IFormlyDebugElement<E>;
+    queryAll: <E extends Element = Element>(selector: string) => IFormlyDebugElement<E>[];
+};
+declare function createFieldComponent(field: FormlyFieldConfig, config?: IComponentOptions<{
+    field: FormlyFieldConfig;
+}>): {
+    field: FormlyFieldConfig;
+} & {
+    fixture: ComponentFixture<{
+        field: FormlyFieldConfig;
+    }>;
+    detectChanges: (checkNoChanges?: boolean) => void;
+    setInputs: (inputs: Partial<{
+        field: FormlyFieldConfig;
+    }>) => void;
+    query: <E extends Element = Element>(selector: string) => IFormlyDebugElement<E>;
+    queryAll: <E extends Element = Element>(selector: string) => IFormlyDebugElement<E>[];
+};
+
+export { createComponent, createFieldComponent };

package/json-schema/formly-json-schema.service.d.ts

@@ -1,36 +0,0 @@
-import { FormlyFieldConfig } from '@ngx-formly/core';
-import { JSONSchema7 } from 'json-schema';
-import * as i0 from "@angular/core";
-export interface FormlyJsonschemaOptions {
-    /**
-     * allows to intercept the mapping, taking the already mapped
-     * formly field and the original JSONSchema source from which it
-     * was mapped.
-     */
-    map?: (mappedField: FormlyFieldConfig, mapSource: JSONSchema7) => FormlyFieldConfig;
-}
-export declare class FormlyJsonschema {
-    toFieldConfig(schema: JSONSchema7, options?: FormlyJsonschemaOptions): FormlyFieldConfig;
-    private _toFieldConfig;
-    private resolveSchema;
-    private resolveAllOf;
-    private resolveMultiSchema;
-    private createMultiSchemaField;
-    private ensureMultiSchemaField;
-    private getSchemaField;
-    private isRecursiveMultiSchema;
-    private getDefinition;
-    private resolveDefinition;
-    private resolveDependencies;
-    private extractIfCondition;
-    private resolveIfThenElse;
-    private resolveConditionalSchema;
-    private guessSchemaType;
-    private addValidator;
-    private isEnum;
-    private toEnumOptions;
-    private isFieldValid;
-    private mergeFields;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyJsonschema, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FormlyJsonschema>;
-}

package/json-schema/public_api.d.ts

@@ -1 +0,0 @@
-export { FormlyJsonschema } from './formly-json-schema.service';

package/lib/components/formly.field.d.ts

@@ -1,47 +0,0 @@
-import { ViewContainerRef, SimpleChanges, DoCheck, OnInit, OnChanges, OnDestroy, AfterContentInit, AfterViewInit, Renderer2, ElementRef, Injector } from '@angular/core';
-import { FormlyConfig } from '../services/formly.config';
-import { FormlyFieldConfig, FormlyFieldConfigCache } from '../models';
-import { FormlyFieldTemplates } from './formly.template';
-import * as i0 from "@angular/core";
-/**
- * The `<formly-field>` component is used to render the UI widget (layout + type) of a given `field`.
- */
-export declare class FormlyField implements DoCheck, OnInit, OnChanges, AfterContentInit, AfterViewInit, OnDestroy {
-    private config;
-    private renderer;
-    private _elementRef;
-    private hostContainerRef;
-    private injector;
-    private form;
-    /** The field config. */
-    field: FormlyFieldConfig;
-    viewContainerRef: ViewContainerRef;
-    private hostObservers;
-    private componentRefs;
-    private hooksObservers;
-    private detectFieldBuild;
-    private get containerRef();
-    private get elementRef();
-    valueChangesUnsubscribe: () => void;
-    constructor(config: FormlyConfig, renderer: Renderer2, _elementRef: ElementRef, hostContainerRef: ViewContainerRef, injector: Injector, form: FormlyFieldTemplates);
-    ngAfterContentInit(): void;
-    ngAfterViewInit(): void;
-    ngDoCheck(): void;
-    ngOnInit(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    private renderField;
-    private triggerHook;
-    attachLocalField(field?: FormlyFieldConfigCache, previousField?: FormlyFieldConfigCache): void;
-    private createFieldInjector;
-    private attachComponentRef;
-    private render;
-    private resetRefs;
-    private fieldChanges;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyField, [null, null, null, null, null, { optional: true; }]>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyField, "formly-field", never, { "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
-}
-export declare class LegacyFormlyField extends FormlyField {
-    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyFormlyField, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LegacyFormlyField, "formly-field", never, {}, {}, never, never, false, never>;
-}

package/lib/components/formly.form.d.ts

@@ -1,50 +0,0 @@
-import { DoCheck, OnChanges, SimpleChanges, EventEmitter, OnDestroy, NgZone, QueryList } from '@angular/core';
-import { UntypedFormGroup, UntypedFormArray } from '@angular/forms';
-import { FormlyFieldConfig, FormlyFormOptions, FormlyFieldConfigCache } from '../models';
-import { FormlyFormBuilder } from '../services/formly.builder';
-import { FormlyConfig } from '../services/formly.config';
-import { FormlyFieldTemplates, FormlyTemplate } from './formly.template';
-import * as i0 from "@angular/core";
-/**
- * The `<form-form>` component is the main container of the form,
- * which takes care of managing the form state
- * and delegates the rendering of each field to `<formly-field>` component.
- */
-export declare class FormlyForm implements DoCheck, OnChanges, OnDestroy {
-    private builder;
-    private config;
-    private ngZone;
-    protected fieldTemplates: FormlyFieldTemplates;
-    /** The form instance which allow to track model value and validation status. */
-    set form(form: UntypedFormGroup | UntypedFormArray);
-    get form(): UntypedFormGroup | UntypedFormArray;
-    /** The model to be represented by the form. */
-    set model(model: any);
-    get model(): any;
-    /** The field configurations for building the form. */
-    set fields(fieldGroup: FormlyFieldConfig[]);
-    get fields(): FormlyFieldConfig[];
-    /** Options for the form. */
-    set options(options: FormlyFormOptions);
-    get options(): FormlyFormOptions;
-    /** Event that is emitted when the model value is changed */
-    modelChange: EventEmitter<any>;
-    set templates(templates: QueryList<FormlyTemplate>);
-    field: FormlyFieldConfigCache;
-    private _modelChangeValue;
-    private valueChangesUnsubscribe;
-    constructor(builder: FormlyFormBuilder, config: FormlyConfig, ngZone: NgZone, fieldTemplates: FormlyFieldTemplates);
-    ngDoCheck(): void;
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
-    private checkExpressionChange;
-    private valueChanges;
-    private setField;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyForm, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FormlyForm, "formly-form", never, { "form": { "alias": "form"; "required": false; }; "model": { "alias": "model"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "modelChange": "modelChange"; }, ["templates"], never, true, never>;
-}
-export declare class LegacyFormlyForm extends FormlyForm {
-    set templates(templates: QueryList<FormlyTemplate>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyFormlyForm, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LegacyFormlyForm, "formly-form", never, {}, {}, ["templates"], never, false, never>;
-}

package/lib/components/formly.template.d.ts

@@ -1,19 +0,0 @@
-import { OnChanges, QueryList, TemplateRef } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class FormlyTemplate implements OnChanges {
-    ref: TemplateRef<any>;
-    name: string;
-    constructor(ref: TemplateRef<any>);
-    ngOnChanges(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyTemplate, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FormlyTemplate, "[formlyTemplate]", never, { "name": { "alias": "formlyTemplate"; "required": false; }; }, {}, never, never, true, never>;
-}
-export declare class LegacyFormlyTemplate extends FormlyTemplate {
-    static ɵfac: i0.ɵɵFactoryDeclaration<LegacyFormlyTemplate, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<LegacyFormlyTemplate, "[formlyTemplate]", never, {}, {}, never, never, false, never>;
-}
-export declare class FormlyFieldTemplates {
-    templates: QueryList<FormlyTemplate>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyFieldTemplates, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<FormlyFieldTemplates>;
-}

package/lib/core.config.d.ts

@@ -1,11 +0,0 @@
-import { InjectionToken, Provider } from '@angular/core';
-import { ConfigOption } from './models';
-import { FormlyConfig } from './services/formly.config';
-/**
- * An InjectionToken for registering additional formly config options (types, wrappers ...).
- */
-export declare const FORMLY_CONFIG: InjectionToken<ConfigOption[]>;
-export declare function withDefaultConfig(config: FormlyConfig): ConfigOption;
-export declare function withFormlyFieldExpression(): ConfigOption;
-export declare const provideFormlyCore: (configs?: ConfigOption | ConfigOption[]) => Provider;
-export declare const provideFormlyConfig: (configs?: ConfigOption | ConfigOption[]) => Provider;

package/lib/core.d.ts

@@ -1,20 +0,0 @@
-export { provideFormlyCore, provideFormlyConfig, FORMLY_CONFIG, withFormlyFieldExpression } from './core.config';
-export { LegacyFormlyForm, FormlyForm } from './components/formly.form';
-export { FormlyFieldConfig, FormlyTemplateOptions, FormlyFormOptions, FormlyFieldProps, ConfigOption, FormlyExtension, FormlyFieldConfigPresetProvider, FormlyAttributeEvent, ValidationMessageOption, } from './models';
-export { LegacyFormlyField, FormlyField } from './components/formly.field';
-export { LegacyFormlyAttributes, FormlyAttributes } from './templates/formly.attributes';
-export { FormlyGroup as ɵFormlyGroup } from './templates/formly.group';
-export { FormlyTemplate, LegacyFormlyTemplate as ɵFormlyTemplate } from './components/formly.template';
-export { LegacyFormlyValidationMessage, FormlyValidationMessage } from './templates/formly.validation-message';
-export { FormlyConfig } from './services/formly.config';
-export { FormlyFormBuilder } from './services/formly.builder';
-export { FieldType, FieldTypeConfig, FieldGroupTypeConfig } from './templates/field.type';
-export { FieldArrayType, FieldArrayTypeConfig } from './templates/field-array.type';
-export { FieldWrapper } from './templates/field.wrapper';
-export { FormlyModule } from './core.module';
-export { defineHiddenProp as ɵdefineHiddenProp } from './utils';
-export { reverseDeepMerge as ɵreverseDeepMerge } from './utils';
-export { getFieldValue as ɵgetFieldValue } from './utils';
-export { clone as ɵclone } from './utils';
-export { observe as ɵobserve } from './utils';
-export { hasKey as ɵhasKey } from './utils';

package/lib/core.module.d.ts

@@ -1,25 +0,0 @@
-import { ModuleWithProviders } from '@angular/core';
-import { ConfigOption } from './models';
-import * as i0 from "@angular/core";
-import * as i1 from "./components/formly.template";
-import * as i2 from "./components/formly.form";
-import * as i3 from "./components/formly.field";
-import * as i4 from "./templates/formly.attributes";
-import * as i5 from "./templates/formly.validation-message";
-import * as i6 from "./templates/formly.group";
-import * as i7 from "./templates/field-template.type";
-import * as i8 from "@angular/common";
-/**
- * Registers Formly components and configuration for NgModule-based applications.
- *
- * `forRoot()` provides the shared `FormlyConfig` at the application root, while
- * `forChild()` adds feature configuration using the inherited service. This follows
- * Angular's [root/child module registration convention](https://frontendatlas.com/angular/trivia/angular-forroot-forchild).
- */
-export declare class FormlyModule {
-    static forRoot(config?: ConfigOption): ModuleWithProviders<FormlyModule>;
-    static forChild(config?: ConfigOption): ModuleWithProviders<FormlyModule>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FormlyModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<FormlyModule, [typeof i1.LegacyFormlyTemplate, typeof i2.LegacyFormlyForm, typeof i3.LegacyFormlyField, typeof i4.LegacyFormlyAttributes, typeof i5.LegacyFormlyValidationMessage, typeof i6.FormlyGroup, typeof i7.FormlyTemplateType], [typeof i8.CommonModule], [typeof i1.LegacyFormlyTemplate, typeof i2.LegacyFormlyForm, typeof i3.LegacyFormlyField, typeof i4.LegacyFormlyAttributes, typeof i5.LegacyFormlyValidationMessage, typeof i6.FormlyGroup]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<FormlyModule>;
-}

package/lib/extensions/core/core.d.ts

@@ -1,14 +0,0 @@
-import { FormlyConfig } from '../../services/formly.config';
-import { FormlyFieldConfigCache, FormlyExtension } from '../../models';
-export declare class CoreExtension implements FormlyExtension {
-    private config;
-    private formId;
-    constructor(config: FormlyConfig);
-    prePopulate(field: FormlyFieldConfigCache): void;
-    onPopulate(field: FormlyFieldConfigCache): void;
-    postPopulate(field: FormlyFieldConfigCache): void;
-    private initFieldProps;
-    private initRootOptions;
-    private initFieldOptions;
-    private getFieldComponentInstance;
-}

package/lib/extensions/field-expression/field-expression.d.ts

@@ -1,4 +0,0 @@
-import { FieldExpressionExtension as FieldExpressionLegacyExtension } from '../field-expression-legacy/field-expression';
-export declare class FieldExpressionExtension extends FieldExpressionLegacyExtension {
-    protected _evalStringExpression(expression: string, argNames: string[]): any;
-}

package/lib/extensions/field-expression/utils.d.ts

@@ -1,4 +0,0 @@
-/**
- * Uses CSP-safe implementation
- */
-export declare function parseExpression(expression: string, argNames: string[]): any;

package/lib/extensions/field-expression-legacy/field-expression.d.ts

@@ -1,16 +0,0 @@
-import { FormlyFieldConfigCache } from '../../models';
-import { FormlyExtension } from '../../models';
-export declare class FieldExpressionExtension implements FormlyExtension {
-    onPopulate(field: FormlyFieldConfigCache): void;
-    postPopulate(field: FormlyFieldConfigCache): void;
-    protected parseExpressions(field: FormlyFieldConfigCache, path: string, expr: any): {
-        callback: (ignoreCache?: boolean) => boolean;
-    };
-    protected _evalStringExpression(expression: string, argNames: string[]): any;
-    private checkExpressions;
-    private changeDisabledState;
-    private changeHideState;
-    private evalExpr;
-    private emitExpressionChanges;
-    private _evalExpressionPath;
-}

package/lib/extensions/field-expression-legacy/utils.d.ts

@@ -1,5 +0,0 @@
-/**
- * Legacy implementation
- */
-export declare function evalStringExpressionLegacy(expression: string, argNames: string[]): any;
-export declare function evalExpression(expression: string | ((...value: any[]) => any) | boolean, thisArg: any, argVal: any[]): any;

package/lib/extensions/field-form/field-form.d.ts

@@ -1,11 +0,0 @@
-import { FormlyExtension, FormlyFieldConfigCache } from '../../models';
-export declare class FieldFormExtension implements FormlyExtension {
-    private root;
-    prePopulate(field: FormlyFieldConfigCache): void;
-    onPopulate(field: FormlyFieldConfigCache): void;
-    postPopulate(field: FormlyFieldConfigCache): void;
-    private addFormControl;
-    private setValidators;
-    private hasValidators;
-    private mergeValidators;
-}

package/lib/extensions/field-form/utils.d.ts

@@ -1,7 +0,0 @@
-import { AbstractControl } from '@angular/forms';
-import { FormlyFieldConfigCache } from '../../models';
-export declare function unregisterControl(field: FormlyFieldConfigCache, emitEvent?: boolean): void;
-export declare function findControl(field: FormlyFieldConfigCache): AbstractControl;
-export declare function registerControl(field: FormlyFieldConfigCache, control?: FormlyFieldConfigCache['formControl'], emitEvent?: boolean): void;
-export declare function updateValidity(c: AbstractControl, onlySelf?: boolean): void;
-export declare function clearControl(form: FormlyFieldConfigCache['formControl']): void;

package/lib/extensions/field-validation/field-validation.d.ts

@@ -1,11 +0,0 @@
-import { FormlyConfig } from '../../services/formly.config';
-import { FormlyExtension, FormlyFieldConfigCache } from '../../models';
-export declare class FieldValidationExtension implements FormlyExtension {
-    private config;
-    constructor(config: FormlyConfig);
-    onPopulate(field: FormlyFieldConfigCache): void;
-    private initFieldValidation;
-    private getPredefinedFieldValidation;
-    private wrapNgValidatorFn;
-    private handleResult;
-}

package/lib/models/config.d.ts

@@ -1,90 +0,0 @@
-import { Type } from '@angular/core';
-import { ValidationErrors, AbstractControl } from '@angular/forms';
-import { Observable } from 'rxjs';
-import { FormlyFieldConfig } from './fieldconfig';
-import { FieldType } from './../templates/field.type';
-import { FieldWrapper } from '../templates/field.wrapper';
-export interface FormlyExtension<F extends FormlyFieldConfig = FormlyFieldConfig> {
-    priority?: number;
-    prePopulate?(field: F): void;
-    onPopulate?(field: F): void;
-    postPopulate?(field: F): void;
-}
-export interface TypeOption {
-    name: string;
-    component?: Type<FieldType>;
-    wrappers?: string[];
-    extends?: string;
-    defaultOptions?: FormlyFieldConfig;
-}
-export interface WrapperOption {
-    name: string;
-    component: Type<FieldWrapper>;
-    types?: string[];
-}
-export type FieldValidatorFn = (c: AbstractControl, field: FormlyFieldConfig, options?: {
-    [id: string]: any;
-}) => ValidationErrors | null;
-export interface ValidatorOption {
-    name: string;
-    validation: FieldValidatorFn;
-    options?: {
-        [id: string]: any;
-    };
-}
-export interface ExtensionOption {
-    name: string;
-    extension: FormlyExtension;
-    priority?: number;
-}
-export interface ValidationMessageOption {
-    name: string;
-    message: string | ((error: any, field: FormlyFieldConfig) => string | Observable<string>);
-}
-export interface PresetOption {
-    name: string;
-    config: FormlyFieldConfig | FormlyFieldConfigPresetProvider;
-}
-export interface FormlyFieldConfigPresetProvider {
-    getConfiguration: () => FormlyFieldConfig;
-}
-export interface ConfigOption {
-    types?: TypeOption[];
-    wrappers?: WrapperOption[];
-    validators?: ValidatorOption[];
-    extensions?: ExtensionOption[];
-    validationMessages?: ValidationMessageOption[];
-    extras?: {
-        immutable?: boolean;
-        showError?: (field: FieldType) => boolean;
-        /**
-         * Defines the option which formly rely on to check field expression properties.
-         * - `modelChange`: perform a check when the value of the form control changes.
-         * - `changeDetectionCheck`: triggers an immediate check when `ngDoCheck` is called.
-         *
-         * Defaults to `modelChange`.
-         */
-        checkExpressionOn?: 'modelChange' | 'changeDetectionCheck';
-        /**
-         * Whether to lazily render field components or not when marked as hidden.
-         * - `true`: lazily render field components.
-         * - `false`: render field components and use CSS to control their visibility.
-         *
-         * Defaults to `true`.
-         */
-        lazyRender?: boolean;
-        /**
-         * When `true`, reset the value of a hidden field.
-         *
-         * Defaults to `true`.
-         */
-        resetFieldOnHide?: boolean;
-        /**
-         * Whether to render fields inside <formly-field> component or not.
-         *
-         * Defaults to `true`.
-         */
-        renderFormlyFieldElement?: boolean;
-    };
-    presets?: PresetOption[];
-}

package/lib/models/fieldconfig.cache.d.ts

@@ -1,50 +0,0 @@
-import { ComponentRef, ElementRef, EmbeddedViewRef, Injector, ViewContainerRef } from '@angular/core';
-import { AsyncValidatorFn, ValidatorFn, UntypedFormArray, UntypedFormGroup, AbstractControl } from '@angular/forms';
-import { Observable, Subscription } from 'rxjs';
-import { FieldType } from '../templates/field.type';
-import { FormlyExtension } from './config';
-import { FormlyFieldConfig, FormlyFormOptions } from './fieldconfig';
-export interface FormlyFieldConfigCache extends FormlyFieldConfig {
-    form?: UntypedFormGroup | UntypedFormArray;
-    model?: any;
-    formControl?: AbstractControl & {
-        _fields?: FormlyFieldConfigCache[];
-        _childrenErrors?: {
-            [id: string]: () => void;
-        };
-    };
-    parent?: FormlyFieldConfigCache;
-    options?: FormlyFormOptionsCache;
-    shareFormControl?: boolean;
-    index?: number;
-    _localFields?: FormlyFieldConfigCache[];
-    _elementRefs?: ElementRef[];
-    _expressions?: {
-        [property: string]: {
-            callback?: (ingoreCache: boolean) => boolean;
-            paths?: string[];
-            subscription?: Subscription | null;
-            value$?: Observable<any>;
-        };
-    };
-    _hide?: boolean;
-    _validators?: ValidatorFn[];
-    _asyncValidators?: AsyncValidatorFn[];
-    _componentRefs?: (ComponentRef<FieldType> | EmbeddedViewRef<FieldType>)[];
-    _proxyInstance?: FormlyExtension;
-    _keyPath?: {
-        key: FormlyFieldConfig['key'];
-        path: string[];
-    };
-}
-export interface FormlyFormOptionsCache extends FormlyFormOptions {
-    checkExpressions?: (field: FormlyFieldConfig, ingoreCache?: boolean) => void;
-    _viewContainerRef?: ViewContainerRef;
-    _injector?: Injector;
-    _hiddenFieldsForCheck?: {
-        field: FormlyFieldConfigCache;
-        default?: boolean;
-    }[];
-    _initialModel?: any;
-    _detectChanges?: (field: FormlyFieldConfig) => void;
-}