### File

`src/lib/types.ts`

### Index

###### Properties

- Optional coerce
- Optional emitEvent
- Optional emitModelToViewChange
- Optional emitViewToModelChange
- Optional initial
- Optional onlySelf
- Optional strict

### Properties

coerce
`coerce: `boolean``
Type : `boolean`
Optional
used in the RxapFormArray patchValue method. true - if the value has not a control with any index. The control is created false - default behavior

emitEvent
`emitEvent: `boolean``
Type : `boolean`
Optional

emitModelToViewChange
`emitModelToViewChange: `boolean``
Type : `boolean`
Optional

emitViewToModelChange
`emitViewToModelChange: `boolean``
Type : `boolean`
Optional

initial
`initial: `boolean``
Type : `boolean`
Optional

onlySelf
`onlySelf: `boolean``
Type : `boolean`
Optional

strict
`strict: `boolean``
Type : `boolean`
Optional
used in the RxapFormArray patchValue method. true - the length of the control array is limited by the length of the value. false - default behavior example with strict = true current from array controls: [ 0: {}, 1: {}, 2: {} ] patch value A: [ 0: {}, 1: {}, 2: {} ] result: [ 0: {}, 1: {}, 2: {} ] path value B: [ 0: {}, 1: {} ] result: [ 0: {}, 1: {} ]

    import {
      AbstractControl as NgAbstractControl,
      AbstractControlOptions as NgAbstractControlOptions,
      ValidationErrors as NgValidationErrors,
    } from '@angular/forms';
    import {
      Observable,
      Subject,
    } from 'rxjs';
    import { RxapFormArray } from './form-array';
    import { RxapFormControl } from './form-control';
    import { RxapFormGroup } from './form-group';
    import { FormDefinition } from './model';

    export type ValidationErrors<T = NgValidationErrors> = T;
    export type ValidatorFn<T = any, E = any> = (control: AbstractControl<T>) => ValidationErrors<E> | null;
    export type AsyncValidatorFn<T = any, E = any> = (
      control: AbstractControl<T>,
    ) => Promise<ValidationErrors<E> | null> | Observable<ValidationErrors<E> | null>;

    export interface AbstractControlOptions<T = any, E extends NgValidationErrors = any> extends NgAbstractControlOptions {
      validators?: ValidatorFn<T, E> | ValidatorFn<T, E>[] | null;
      asyncValidators?: AsyncValidatorFn<T, E> | AsyncValidatorFn<T, E>[] | null;
    }

    export type ValidatorOrOpts = ValidatorFn | ValidatorFn[] | AbstractControlOptions | null;
    export type AsyncValidator = AsyncValidatorFn | AsyncValidatorFn[] | null;
    export type Validator = ValidatorFn | ValidatorFn[];

    export interface ControlOptions {
      onlySelf?: boolean;
      emitEvent?: boolean;
      emitModelToViewChange?: boolean;
      emitViewToModelChange?: boolean;
      initial?: boolean;
      /**
       * used in the RxapFormArray patchValue method.
       *
       * true - if the value has not a control with any index. The control is created
       * false - default behavior
       */
      coerce?: boolean;

      /**
       * used in the RxapFormArray patchValue method.
       *
       * true - the length of the control array is limited by the length of the value.
       * false - default behavior
       *
       * example with strict = true
       *
       * current from array controls: [ 0: {}, 1: {}, 2: {} ]
       *
       * patch value A: [ 0: {}, 1: {}, 2: {} ]
       * result: [ 0: {}, 1: {}, 2: {} ]
       *
       * path value B: [ 0: {}, 1: {} ]
       * result: [ 0: {}, 1: {} ]
       *
       */
      strict?: boolean;
    }

    export type ControlEventOptions = Pick<ControlOptions, 'emitEvent' | 'onlySelf' | 'coerce' | 'strict'>;
    export type OnlySelf = Pick<ControlOptions, 'onlySelf'>;
    export type EmitEvent = Pick<ControlOptions, 'emitEvent'>;
    export type ControlPath = Array<string | number> | string;
    export type ControlState = 'VALID' | 'INVALID' | 'PENDING' | 'DISABLED';

    export interface AbstractControl<T = any> extends NgAbstractControl {
      value: T;
      controlId?: string;
      fullControlPath?: string;
      rxapFormDefinition?: FormDefinition;
      readonly?: boolean;
      stateChanges?: Subject<any>;
    }

    export type ExtractStrings<T> = Extract<keyof T, string>;

    export interface NgValidatorsErrors {
      required: true;
      email: true;
      pattern: { requiredPattern: string; actualValue: string };
      minlength: { requiredLength: number; actualLength: number };
      maxlength: { requiredLength: number; actualLength: number };
      min: { min: number; actual: number };
      max: { max: number; actual: number };
    }

    export interface BoxedValue<T> {
      value: T;
      disabled?: boolean;
    }

    export type OrBoxedValue<T> = T | BoxedValue<T> | (() => T);

    type ArrayType<T> = T extends Array<infer R> ? R : any;

    export type KeyValueControls<T> = {
      [K in keyof T]: T[K] extends RxapFormControl<T[K]>
        ? RxapFormControl<T[K]>
        : T[K] extends RxapFormGroup<T[K]>
          ? RxapFormGroup<T[K]>
          : T[K] extends RxapFormArray<ArrayType<T[K]>>
            ? RxapFormArray<ArrayType<T[K]>>
            : AbstractControl<T[K]>;
    };
    export type ExtractAbstractControl<T, U> = T extends KeyValueControls<any>
      ? { [K in keyof U]: AbstractControl<U[K]> }
      : T;

# results matching ""

# No results matching ""