@ngx-formly/core 6.0.0-rc.0 → 6.0.0

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

@@ -3,12 +3,16 @@ import { FormlyConfig } from '../services/formly.config';
 import { FormlyFieldConfig } 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 form;
+    /** The field config. */
     field: FormlyFieldConfig;
     viewContainerRef: ViewContainerRef;
     private hostObservers;

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

@@ -5,19 +5,29 @@ 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;
     private fieldTemplates;
+    /** The form instance which allow to track model value and validation status. */
     set form(form: FormGroup | FormArray);
     get form(): FormGroup | FormArray;
+    /** 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;

package/lib/models/config.d.ts

@@ -1,7 +1,9 @@
+import { Type } from '@angular/core';
 import { ValidationErrors, AbstractControl } from '@angular/forms';
-import { FieldType } from './../templates/field.type';
-import { FormlyFieldConfig } from './fieldconfig';
 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;
@@ -10,14 +12,14 @@ export interface FormlyExtension<F extends FormlyFieldConfig = FormlyFieldConfig
 }
 export interface TypeOption {
     name: string;
-    component?: any;
+    component?: Type<FieldType>;
     wrappers?: string[];
     extends?: string;
     defaultOptions?: FormlyFieldConfig;
 }
 export interface WrapperOption {
     name: string;
-    component: any;
+    component: Type<FieldWrapper>;
     types?: string[];
 }
 export declare type FieldValidatorFn = (c: AbstractControl, field: FormlyFieldConfig, options?: {

package/lib/models/fieldconfig.d.ts

@@ -1,4 +1,4 @@
-import { FormGroup, FormArray, AbstractControl, FormGroupDirective } from '@angular/forms';
+import { FormGroup, FormArray, AbstractControl, FormGroupDirective, ValidatorFn, AsyncValidatorFn } from '@angular/forms';
 import { Subject, Observable } from 'rxjs';
 import { FieldType } from '../templates/field.type';
 import { FieldWrapper } from '../templates/field.wrapper';
@@ -54,23 +54,13 @@ export interface FormlyFieldConfig<Props = FormlyFieldProps & {
      * Used to set validation rules for a particular field.
      * Should be an object of key - value pairs. The value can either be an expression to evaluate or a function to run.
      * Each should return a boolean value, returning true when the field is valid. See Validation for more information.
-     *
-     * {
-     *   validation?: (string | ValidatorFn)[];
-     *   [key: string]: ((control: AbstractControl, field: FormlyFieldConfig) => boolean) | ({ expression: (control: AbstractControl, field: FormlyFieldConfig) => boolean, message: ValidationMessageOption['message'] });
-     * }
      */
-    validators?: any;
+    validators?: FormlyValidation<ValidatorFn, boolean>;
     /**
      * Use this one for anything that needs to validate asynchronously.
      * Pretty much exactly the same as the validators api, except it must be a function that returns a promise.
-     *
-     * {
-     *   validation?: (string | AsyncValidatorFn)[];
-     *   [key: string]: ((control: AbstractControl, field: FormlyFieldConfig) => Promise<boolean> | Observable<boolean>) | ({ expression: (control: AbstractControl, field: FormlyFieldConfig) => Promise<boolean> | Observable<boolean>, message: string });
-     * }
      */
-    asyncValidators?: any;
+    asyncValidators?: FormlyValidation<AsyncValidatorFn, Promise<boolean> | Observable<boolean>>;
     /**
      * Can be set instead of `type` to render custom html content.
      */
@@ -105,7 +95,7 @@ export interface FormlyFieldConfig<Props = FormlyFieldProps & {
      * An object where the key is a property to be set on the main field config and the value is an expression used to assign that property.
      */
     expressions?: {
-        [property: string]: string | ((field?: FormlyFieldConfig) => any) | Observable<any>;
+        [property: string]: string | ((field: FormlyFieldConfig) => any) | Observable<any>;
     };
     /**
      * You can specify your own class that will be applied to the `formly-field` component.
@@ -190,7 +180,7 @@ export interface FormlyFieldProps {
     /** @deprecated use `minLength` */
     minlength?: number;
     maxLength?: number;
-    /** @deprecated use `minLength` */
+    /** @deprecated use `maxLength` */
     maxlength?: number;
     pattern?: string | RegExp;
     required?: boolean;
@@ -233,3 +223,13 @@ export interface FormlyValueChangeEvent {
     value: any;
     [meta: string]: any;
 }
+interface FormlyValidation<T, R> {
+    validation?: (string | T)[] | any;
+    [key: string]: FormlyValidatorFn<R> | FormlyValidatorExpressionFn<R> | any;
+}
+declare type FormlyValidatorFn<T> = (control: AbstractControl, field: FormlyFieldConfig) => T;
+interface FormlyValidatorExpressionFn<T> {
+    expression: FormlyValidatorFn<T>;
+    message: string | ((error: any, field: FormlyFieldConfig) => string);
+}
+export {};

package/lib/services/formly.config.d.ts

@@ -3,9 +3,12 @@ import { FieldType } from './../templates/field.type';
 import { FormlyFieldConfig, FormlyFieldConfigCache, ConfigOption, TypeOption, ValidatorOption, WrapperOption, FormlyExtension, ValidationMessageOption, FormlyFieldConfigPresetProvider } from '../models';
 import { FieldWrapper } from '../templates/field.wrapper';
 import * as i0 from "@angular/core";
+/**
+ * An InjectionToken for registering additional formly config options (types, wrappers ...).
+ */
 export declare const FORMLY_CONFIG: InjectionToken<ConfigOption[]>;
 /**
- * Maintains list of formly field directive types. This can be used to register new field templates.
+ * Maintains list of formly config options. This can be used to register new field type.
  */
 export declare class FormlyConfig {
     types: {
@@ -29,13 +32,19 @@ export declare class FormlyConfig {
     };
     private extensionsByPriority;
     addConfig(config: ConfigOption): void;
+    /**
+     * 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: TypeOption | TypeOption[]): void;
     getType(name: FormlyFieldConfig['type'], throwIfNotFound?: boolean): TypeOption;
+    /** @ignore */
     getMergedField(field?: FormlyFieldConfig): any;
-    /** @internal */
+    /** @ignore @internal */
     resolveFieldTypeRef(field?: FormlyFieldConfigCache): ComponentRef<FieldType>;
     setWrapper(options: WrapperOption): void;
     getWrapper(name: string | Type<FieldWrapper>): WrapperOption;
+    /** @ignore */
     setTypeWrapper(type: string, name: string): void;
     setValidator(options: ValidatorOption): void;
     getValidator(name: string): ValidatorOption;

package/lib/templates/field-template.type.d.ts

@@ -1,6 +1,7 @@
 import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
 import { FieldType } from './field.type';
 import * as i0 from "@angular/core";
+/** @ignore */
 export declare class FormlyTemplateType extends FieldType {
     private sanitizer;
     get template(): SafeHtml;

package/lib/templates/formly.attributes.d.ts

@@ -1,9 +1,13 @@
 import { ElementRef, OnChanges, SimpleChanges, Renderer2, DoCheck, OnDestroy } from '@angular/core';
 import { FormlyFieldConfig } from '../models';
 import * as i0 from "@angular/core";
+/**
+ * Allow to link the `field` HTML attributes (`id`, `name` ...) and Event attributes (`focus`, `blur` ...) to an element in the DOM.
+ */
 export declare class FormlyAttributes implements OnChanges, DoCheck, OnDestroy {
     private renderer;
     private elementRef;
+    /** The field config. */
     field: FormlyFieldConfig;
     id: string;
     private document;

package/lib/templates/formly.group.d.ts

@@ -1,5 +1,6 @@
 import { FieldType, FieldGroupTypeConfig } from './field.type';
 import * as i0 from "@angular/core";
+/** @ignore */
 export declare class FormlyGroup extends FieldType<FieldGroupTypeConfig> {
     static ɵfac: i0.ɵɵFactoryDeclaration<FormlyGroup, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<FormlyGroup, "formly-group", never, {}, {}, never, ["*"]>;

package/lib/templates/formly.validation-message.d.ts

@@ -3,8 +3,12 @@ import { FormlyConfig } from '../services/formly.config';
 import { FormlyFieldConfig } from '../models';
 import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * The `<formly-validation-message>` component renders the error message of a given `field`.
+ */
 export declare class FormlyValidationMessage implements OnChanges {
     private config;
+    /** The field config. */
     field: FormlyFieldConfig;
     errorMessage$: Observable<string>;
     constructor(config: FormlyConfig);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngx-formly/core",
-  "version": "6.0.0-rc.0",
+  "version": "6.0.0",
   "license": "MIT",
   "dependencies": {
     "tslib": "^2.0.0"