@datorama/akita-ng-forms-manager/lib/forms-manager.d.ts

The best way to manage your Angular form state in Akita

import { AbstractControl, AsyncValidatorFn, ValidatorFn } from '@angular/forms';
import { HashMap } from '@datorama/akita';
import { Observable } from 'rxjs';
import { FormsQuery } from './forms-manager.query';
import { FormsStore } from './forms-manager.store';
import { FormsManagerOptions } from './forms-manager-options';
export declare type AkitaAbstractControl = Pick<AbstractControl, 'value' | 'valid' | 'invalid' | 'disabled' | 'errors' | 'touched' | 'pristine' | 'pending' | 'dirty'> & {
    rawValue: any;
};
export interface AkitaAbstractGroup<C = any> extends AkitaAbstractControl {
    controls: {
        readonly [P in keyof C]: AkitaAbstractControl;
    };
}
export declare type ArrayControlFactory = (value: any) => AbstractControl;
export declare class AkitaNgFormsManager<FormsState = any> {
    private readonly _options;
    private readonly _store;
    private readonly _query;
    private valueChanges;
    private ngForms;
    constructor(options?: Partial<FormsManagerOptions>);
    readonly query: FormsQuery<FormsState>;
    readonly store: FormsStore<FormsState>;
    selectValid(formName: keyof FormsState, path?: string): Observable<boolean>;
    selectDirty(formName: keyof FormsState, path?: string): Observable<boolean>;
    selectDisabled(formName: keyof FormsState, path?: string): Observable<boolean>;
    selectValue<T = any>(formName: keyof FormsState, path?: string): Observable<T>;
    selectErrors(formName: keyof FormsState, path?: string): Observable<any>;
    selectNgForm(formName: keyof FormsState): Observable<AbstractControl>;
    /**
     * If no path specified it means that it's a single FormControl or FormArray
     */
    selectControl(formName: keyof FormsState, path?: string): Observable<AkitaAbstractControl>;
    getControl(formName: keyof FormsState, path?: string): AkitaAbstractControl;
    selectForm(formName: keyof FormsState, options?: {
        filterNil: true;
    }): Observable<AkitaAbstractGroup>;
    getForm<Name extends keyof FormsState>(formName: keyof FormsState): AkitaAbstractGroup<FormsState[Name]>;
    getNgForm(formName: keyof FormsState): AbstractControl;
    hasForm(formName: keyof FormsState): boolean;
    upsert(formName: keyof FormsState, form: AbstractControl, config?: {
        debounceTime?: number;
        emitEvent?: boolean;
        arrControlFactory?: ArrayControlFactory | HashMap<ArrayControlFactory>;
        persistForm?: boolean;
    }): this;
    remove(formName?: keyof FormsState): void;
    unsubscribe(formName?: keyof FormsState, config?: {
        removeNgForm?: boolean;
        updateStore?: boolean;
    }): void;
    private removeFromStore;
    private resolveControl;
    private find;
    private resolveStoreToForm;
    private handleFormArray;
    private cleanArray;
    private buildFormStoreState;
    private updateStore;
    private resolveFormToStore;
    private cloneValue;
    private isObject;
    private storeFormInstance;
    private removeFormInstance;
}
export declare function setValidators(control: AbstractControl, validator: ValidatorFn | ValidatorFn[] | null): void;
export declare function setAsyncValidators(control: AbstractControl, validator: AsyncValidatorFn | AsyncValidatorFn[] | null): void;