@websolutespa/bom-mixer-forms 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @websolutespa/bom-mixer-forms
+
+## 0.0.1
+
+### Patch Changes
+
+- Added: first release.

package/dist/index.d.ts

@@ -0,0 +1,306 @@
+import { IEquatable, IOption } from '@websolutespa/bom-mixer-core';
+import { DependencyList } from 'react';
+
+declare class EventEmitter {
+    protected events_: {
+        [key: string]: ((...args: any[]) => any)[];
+    };
+    on(event: string, listener: (...args: any[]) => any): void;
+    off(event: string, listener: (...args: any[]) => any): void;
+    emit(event: string, ...args: any[]): void;
+    once(event: string, listener: (...args: any[]) => any): void;
+}
+
+declare class FormAbstractCollection<T extends FormControls> extends FormAbstract {
+    controls_: T;
+    constructor(controls: T, validators?: (FormValidator | FormValidator[]));
+    initControl_(controlOrValue: FormAbstract | any, key: any): FormAbstract;
+    protected setInitialOptions(options?: FormOptions): void;
+    protected checkAsyncPropState_(key: string, option?: FormActivator, root?: FormCollection): Promise<boolean>;
+    updateState_(): void;
+    revalidate_(): Promise<void>;
+    protected validate_(root?: FormCollection): Promise<void>;
+    reset(): void;
+    patch(value: any): void;
+    get(key: keyof T): FormAbstract;
+    set(control: FormAbstract, key: keyof T): void;
+    add(control: FormAbstract, key: keyof T): void;
+    remove(control: FormAbstract): void;
+    removeKey(key: keyof T): void;
+    addValidators(...validators: FormValidator[]): void;
+    replaceValidators(...validators: FormValidator[]): void;
+    clearValidators(): void;
+    protected forEach_(callback: Function): void;
+    protected reduce_(callback: Function, result: any): any;
+    protected all_(key: (keyof FormAbstract), value: any): boolean;
+    protected any_(key: (keyof FormAbstract), value: any): boolean;
+    protected map_(): FormAbstract[];
+    get controls(): T;
+    set controls(controls: T);
+    set disabled(disabled: boolean);
+    set readonly(readonly: boolean);
+    set hidden(hidden: boolean);
+    set submitted(submitted: boolean);
+    set touched(touched: boolean);
+    get value(): {
+        [key: string]: any;
+    };
+    set value(value: {
+        [key: string]: any;
+    });
+    get errors(): {
+        [key: string]: any;
+    };
+    set errors(errors: {
+        [key: string]: any;
+    });
+}
+
+declare class FormArray extends FormAbstractCollection<FormAbstract[]> {
+    constructor(controls?: FormAbstract[], validators?: FormValidator | FormValidator[], initialOptions?: FormOptions);
+    forEach_(callback: (control: FormAbstract, key: number) => any): void;
+    map_(): FormAbstract[];
+    get value(): any[];
+    get length(): number;
+    protected init(control: FormAbstract, key: number): void;
+    set(control: FormAbstract, key: number): void;
+    add(control: FormAbstract, key: number): void;
+    push(control: FormAbstract): void;
+    insert(control: FormAbstract, key: number): void;
+    remove(control: FormAbstract): void;
+    removeKey(key: number): void;
+    at(key: number): FormAbstract;
+}
+declare function formArray(controls?: FormAbstract[], validators?: FormValidator | FormValidator[]): FormArray;
+
+declare class FormControl extends FormAbstract {
+    constructor(value?: any, validators?: FormValidator | FormValidator[], initialOptions?: FormOptions);
+}
+declare function formControl(value?: any, validators?: FormValidator | FormValidator[]): FormControl;
+
+declare class FormGroup extends FormAbstractCollection<{
+    [key: string]: FormAbstract;
+}> {
+    constructor(controls?: {
+        [key: string]: FormAbstract | any;
+    }, validators?: FormValidator | FormValidator[], initialOptions?: FormOptions);
+}
+declare function formGroup(controls?: {
+    [key: string]: FormAbstract | any;
+}, validators?: FormValidator | FormValidator[]): FormGroup;
+
+type IControlParam = {
+    uid: number;
+    control: FormControl;
+};
+type IFormOption = {
+    id: IEquatable;
+    name: string;
+};
+type FormOptions = {
+    schema?: ControlType;
+    name?: string;
+    label?: string;
+    value?: string;
+    placeholder?: string;
+    required?: FormActivator;
+    hidden?: FormActivator;
+    disabled?: FormActivator;
+    readonly?: FormActivator;
+    options?: IOption[];
+    optionsExtra?: {
+        asEquatable: boolean;
+    };
+};
+type ValidationError = {
+    [key: string]: any;
+};
+type FormControls = {
+    [key: string]: FormAbstract;
+} | FormAbstract[];
+type FormCollection = FormAbstractCollection<FormControls>;
+type FormActivator = boolean | ((value: any, rootValue: any, control?: FormAbstract, root?: FormCollection) => boolean | Promise<boolean>);
+type FormValidator = (value: any, rootValue: any, control?: FormAbstract, root?: FormCollection) => null | ValidationError;
+type FormAsyncValidator = (value: any, rootValue: any, control?: FormAbstract, root?: FormCollection) => Promise<null | ValidationError>;
+type FormFlags = {
+    [key: string]: boolean;
+};
+type FormErrors = {
+    [key: string]: any;
+};
+type FormValidationError = {
+    key: string;
+    value: any;
+};
+type FormValidationErrors = FormValidationError[];
+type FormState<T> = {
+    value: T | null;
+    flags: FormFlags;
+    errors: FormValidationErrors;
+};
+type ControlType = 'group' | 'array' | string;
+type IFormBuilderControlSchema = {
+    schema: ControlType;
+    name?: string;
+    label?: string;
+    value?: string;
+    placeholder?: string;
+    required?: FormActivator;
+    hidden?: FormActivator;
+    disabled?: FormActivator;
+    readonly?: FormActivator;
+    options?: IOption[];
+    optionsExtra?: {
+        asEquatable: boolean;
+    };
+    validators?: FormValidator | FormValidator[];
+    children?: IFormBuilderSchema;
+};
+type IFormBuilderGroupSchema = {
+    [key: string]: IFormBuilderControlSchema;
+};
+type IFormBuilderArraySchema = IFormBuilderControlSchema[];
+type IFormBuilderGroupValues = {
+    [key: string]: FormGroup | FormArray | FormControl;
+};
+type IFormBuilderSchema = IFormBuilderGroupSchema | IFormBuilderArraySchema;
+type StateValue = StateValue[] | {
+    [key: string]: StateValue;
+} | number | string | boolean | null | undefined;
+
+declare class FormAbstract extends EventEmitter {
+    errors_: ValidationError;
+    value_: any;
+    validators_: FormValidator[];
+    state_: any;
+    name?: string | number;
+    parent?: FormCollection;
+    schema: ControlType;
+    options?: IOption[];
+    optionsExtra?: {
+        asEquatable: boolean;
+    };
+    protected initialOptions_?: FormOptions;
+    private markAsDirty_;
+    constructor(value: any, validators?: (FormValidator | FormValidator[]));
+    protected setInitialOptions(options?: FormOptions): void;
+    protected checkAsyncState_(root?: FormCollection): Promise<boolean>;
+    protected checkAsyncPropState_(key: string, option?: FormActivator, root?: FormCollection): Promise<boolean>;
+    protected revalidate_(): Promise<void>;
+    protected validate_(root?: FormCollection): Promise<void>;
+    validateAndChange_(root?: FormCollection): Promise<void>;
+    protected updateStateAndChange_(): Promise<void>;
+    protected change_(propagate?: boolean): void;
+    protected updateState_(): void;
+    reset(): void;
+    patch(value: any): void;
+    addValidators(...validators: FormValidator[]): void;
+    replaceValidators(...validators: FormValidator[]): void;
+    clearValidators(): void;
+    protected get path(): (string | number)[];
+    protected get root(): FormCollection | FormAbstract;
+    private label_?;
+    get label(): string;
+    set label(label: string);
+    private placeholder_?;
+    get placeholder(): string;
+    set placeholder(placeholder: string);
+    get validators(): FormValidator[];
+    set validators(validators: FormValidator[]);
+    get state(): any;
+    get errors(): ValidationError;
+    get invalid(): any;
+    get disabled(): any;
+    set disabled(disabled: any);
+    get hidden(): any;
+    set hidden(hidden: any);
+    get readonly(): any;
+    set readonly(readonly: any);
+    get dirty(): any;
+    set dirty(dirty: any);
+    get touched(): any;
+    set touched(touched: any);
+    get submitted(): any;
+    set submitted(submitted: any);
+    get valid(): any;
+    get enabled(): any;
+    get visible(): any;
+    get writeable(): any;
+    get pristine(): any;
+    get untouched(): any;
+    get unsubmitted(): any;
+    get value(): any;
+    set value(value: any);
+}
+
+declare function validValue(value: any): any;
+declare function isThenable(result: any): any;
+declare function mapErrors_(errors: FormErrors): FormValidationError[];
+declare function deepCopy<T>(source: T): T;
+declare function valueToString(value: IOption | IOption[] | IEquatable | IEquatable[] | null): string | string[] | undefined;
+declare function stringToValue(value: string | string[] | undefined, options?: IOption[], optionsExtra?: {
+    asEquatable: boolean;
+}): IOption | IOption[] | IEquatable | IEquatable[] | null;
+
+/**
+ * an email pattern validator
+ */
+declare function EmailValidator(): FormValidator;
+
+/**
+ * an equality match validation on another field
+ */
+declare function MatchValidator(getOtherValue: (value: any, rootValue: any, control?: FormAbstract, root?: FormAbstract) => any): FormValidator;
+
+/**
+ * a max string length validator
+ */
+declare function MaxLengthValidator(maxlength: number): FormValidator;
+
+/**
+ * a max number value validator
+ */
+declare function MaxValidator(max: number): FormValidator;
+
+/**
+ * a min string length validator
+ */
+declare function MinLengthValidator(minlength: number): FormValidator;
+
+/**
+ * a min number value validator
+ */
+declare function MinValidator(min: number): FormValidator;
+
+/**
+ * a null validator
+ */
+declare function NullValidator(): FormValidator;
+
+/**
+ * a regex pattern validator
+ */
+declare function PatternValidator(pattern: string | RegExp): FormValidator;
+
+/**
+ * a required dependant on another field
+ */
+declare function RequiredIfValidator(condition: (value: any, rootValue: any, control?: FormAbstract, root?: FormAbstract) => boolean): FormValidator;
+
+/**
+ * a required and true validator
+ */
+declare function RequiredTrueValidator(): FormValidator;
+
+/**
+ * a required validator
+ */
+declare function RequiredValidator(): FormValidator;
+
+declare function useControl<T>(control: FormAbstract): [FormState<T>, (value: T | null) => void, () => void, () => void, FormAbstract];
+
+declare function useForm<T, U extends (FormGroup | FormArray)>(factory: () => U, deps?: DependencyList): [FormState<T>, (value: any) => void, () => void, () => void, U];
+
+declare function useFormBuilder<T, U extends (FormGroup | FormArray)>(schema: IFormBuilderSchema, deps?: DependencyList): [FormState<T>, (value: Partial<T>) => void, () => void, () => void, U];
+
+export { ControlType, EmailValidator, FormAbstract, FormAbstractCollection, FormActivator, FormArray, FormAsyncValidator, FormCollection, FormControl, FormControls, FormErrors, FormFlags, FormGroup, FormOptions, FormState, FormValidationError, FormValidationErrors, FormValidator, IControlParam, IFormBuilderArraySchema, IFormBuilderControlSchema, IFormBuilderGroupSchema, IFormBuilderGroupValues, IFormBuilderSchema, IFormOption, MatchValidator, MaxLengthValidator, MaxValidator, MinLengthValidator, MinValidator, NullValidator, PatternValidator, RequiredIfValidator, RequiredTrueValidator, RequiredValidator, StateValue, ValidationError, deepCopy, formArray, formControl, formGroup, isThenable, mapErrors_, stringToValue, useControl, useForm, useFormBuilder, validValue, valueToString };