@laser-ui/components 0.0.1

package/form/internal/FormError.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CollapseTransition } from '../../internal/transition';
+import { mergeCS } from '../../utils';
+import { TTANSITION_DURING_FAST } from '../../vars';
+export function FormError(props) {
+    const { styled, visible, message, invalid, afterLeave } = props;
+    return (_jsx(CollapseTransition, { originalSize: {
+            height: 'auto',
+        }, collapsedSize: {
+            height: 0,
+        }, enter: visible, during: TTANSITION_DURING_FAST, styles: {
+            enter: { opacity: 0 },
+            entering: {
+                transition: ['height', 'padding', 'margin', 'opacity'].map((attr) => `${attr} ${TTANSITION_DURING_FAST}ms linear`).join(', '),
+            },
+            leaving: {
+                opacity: 0,
+                transition: ['height', 'padding', 'margin', 'opacity'].map((attr) => `${attr} ${TTANSITION_DURING_FAST}ms linear`).join(', '),
+            },
+            leaved: { display: 'none' },
+        }, skipFirstTransition: false, afterLeave: afterLeave, children: (ref, collapseStyle) => (_jsx("div", Object.assign({}, mergeCS(styled('form__error', `form__error--${invalid}`), {
+            style: collapseStyle,
+        }), { ref: ref, title: message, children: message }))) }));
+}

package/form/model/abstract-control.d.ts

@@ -0,0 +1,67 @@
+import type { FormGroup } from './form-group';
+import type { AsyncValidatorFn, FormControlStatus, ValidationErrors, ValidatorFn } from './types';
+export declare abstract class AbstractControl<V = any> {
+    private _parent;
+    private _pristine;
+    private _errors;
+    private _hasOwnPendingAsyncValidator;
+    private _asyncValidationSubscription?;
+    private _composedValidatorFn;
+    private _composedAsyncValidatorFn;
+    private _rawValidators;
+    private _rawAsyncValidators;
+    constructor(validators: ValidatorFn | ValidatorFn[] | null, asyncValidators: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    get validator(): ValidatorFn | null;
+    set validator(validatorFn: ValidatorFn | null);
+    get asyncValidator(): AsyncValidatorFn | null;
+    set asyncValidator(asyncValidatorFn: AsyncValidatorFn | null);
+    get parent(): FormGroup | null;
+    get root(): AbstractControl;
+    get value(): V;
+    get status(): FormControlStatus;
+    get errors(): ValidationErrors | null;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get disabled(): boolean;
+    get enabled(): boolean;
+    get pristine(): boolean;
+    get dirty(): boolean;
+    setValidators(validators: ValidatorFn | ValidatorFn[] | null): void;
+    setAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[] | null): void;
+    addValidators(validators: ValidatorFn | ValidatorFn[]): void;
+    addAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void;
+    removeValidators(validators: ValidatorFn | ValidatorFn[]): void;
+    removeAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void;
+    hasValidator(validator: ValidatorFn): boolean;
+    hasAsyncValidator(validator: AsyncValidatorFn): boolean;
+    clearValidators(): void;
+    clearAsyncValidators(): void;
+    markAsDirty(onlySelf?: boolean): void;
+    markAsPristine(onlySelf?: boolean): void;
+    markAsPending(onlySelf?: boolean): void;
+    disable(onlySelf?: boolean): void;
+    enable(onlySelf?: boolean): void;
+    setParent(parent: FormGroup): void;
+    setErrors(errors: ValidationErrors | null): void;
+    updateValueAndValidity(onlySelf?: boolean): void;
+    protected abstract _value: V;
+    protected abstract _status: FormControlStatus;
+    abstract setValue(value: V, onlySelf?: boolean): void;
+    abstract patchValue(value: any, onlySelf?: boolean): void;
+    abstract reset(value?: any, onlySelf?: boolean): void;
+    protected abstract _updateValue(): void;
+    protected abstract _forEachChild(cb: (c: AbstractControl) => void): void;
+    protected abstract _anyControls(condition: (c: AbstractControl) => boolean): boolean;
+    protected abstract _allControlsDisabled(): boolean;
+    protected _anyControlsHaveStatus(status: FormControlStatus): boolean;
+    protected _anyControlsDirty(): boolean;
+    protected _parentMarkedDirty(onlySelf: boolean): boolean;
+    protected _updatePristine(onlySelf?: boolean): void;
+    protected _updateControlsErrors(): void;
+    protected _calculateStatus(): FormControlStatus;
+    protected _updateAncestors(onlySelf: boolean, skipPristineCheck: boolean): void;
+    protected _runValidator(): ValidationErrors | null;
+    protected _cancelExistingSubscription(): void;
+    protected _runAsyncValidator(): void;
+}

package/form/model/abstract-control.js

@@ -0,0 +1,335 @@
+import { isArray } from 'lodash';
+import { forkJoin, from } from 'rxjs';
+import { DISABLED, INVALID, PENDING, VALID } from './vars';
+function mergeErrors(arrayOfErrors) {
+    const res = {};
+    arrayOfErrors.forEach((errors) => {
+        if (errors != null) {
+            Object.assign(res, errors);
+        }
+    });
+    return Object.keys(res).length === 0 ? null : res;
+}
+function composeValidators(validators) {
+    const presentValidators = validators.filter((validator) => validator !== null);
+    if (presentValidators.length === 0) {
+        return null;
+    }
+    return function (control) {
+        return mergeErrors(presentValidators.map((fn) => fn(control)));
+    };
+}
+function composeAsyncValidators(validators) {
+    const presentValidators = validators.filter((validator) => validator !== null);
+    if (presentValidators.length === 0) {
+        return null;
+    }
+    return function (control) {
+        return new Promise((resolve) => {
+            const observables = forkJoin(presentValidators.map((fn) => fn(control)));
+            observables.subscribe({
+                next: (errors) => {
+                    resolve(mergeErrors(errors));
+                },
+            });
+        });
+    };
+}
+function coerceToValidator(validator) {
+    return isArray(validator) ? composeValidators(validator) : validator;
+}
+function coerceToAsyncValidator(asyncValidator) {
+    return isArray(asyncValidator) ? composeAsyncValidators(asyncValidator) : asyncValidator;
+}
+function makeValidatorsArray(validators) {
+    if (!validators) {
+        return [];
+    }
+    return isArray(validators) ? validators : [validators];
+}
+function hasValidator(validators, validator) {
+    return Array.isArray(validators) ? validators.includes(validator) : validators === validator;
+}
+function addValidators(validators, currentValidators) {
+    const current = makeValidatorsArray(currentValidators);
+    const validatorsToAdd = makeValidatorsArray(validators);
+    return current.concat(validatorsToAdd.filter((validator) => !hasValidator(current, validator)));
+}
+function removeValidators(validators, currentValidators) {
+    return makeValidatorsArray(currentValidators).filter((validator) => !hasValidator(validators, validator));
+}
+export class AbstractControl {
+    constructor(validators, asyncValidators) {
+        Object.defineProperty(this, "_parent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_pristine", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "_errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "_hasOwnPendingAsyncValidator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "_asyncValidationSubscription", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_composedValidatorFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_composedAsyncValidatorFn", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_rawValidators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_rawAsyncValidators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this._rawValidators = validators;
+        this._rawAsyncValidators = asyncValidators;
+        this._composedValidatorFn = coerceToValidator(this._rawValidators);
+        this._composedAsyncValidatorFn = coerceToAsyncValidator(this._rawAsyncValidators);
+    }
+    get validator() {
+        return this._composedValidatorFn;
+    }
+    set validator(validatorFn) {
+        this._rawValidators = this._composedValidatorFn = validatorFn;
+    }
+    get asyncValidator() {
+        return this._composedAsyncValidatorFn;
+    }
+    set asyncValidator(asyncValidatorFn) {
+        this._rawAsyncValidators = this._composedAsyncValidatorFn = asyncValidatorFn;
+    }
+    get parent() {
+        return this._parent;
+    }
+    get root() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let control = this;
+        while (control.parent) {
+            control = control.parent;
+        }
+        return control;
+    }
+    get value() {
+        return this._value;
+    }
+    get status() {
+        return this._status;
+    }
+    get errors() {
+        return this._errors;
+    }
+    get valid() {
+        return this._status === VALID;
+    }
+    get invalid() {
+        return this._status === INVALID;
+    }
+    get pending() {
+        return this._status === PENDING;
+    }
+    get disabled() {
+        return this._status === DISABLED;
+    }
+    get enabled() {
+        return this._status !== DISABLED;
+    }
+    get pristine() {
+        return this._pristine;
+    }
+    get dirty() {
+        return !this._pristine;
+    }
+    setValidators(validators) {
+        this._rawValidators = validators;
+        this._composedValidatorFn = coerceToValidator(validators);
+    }
+    setAsyncValidators(validators) {
+        this._rawAsyncValidators = validators;
+        this._composedAsyncValidatorFn = coerceToAsyncValidator(validators);
+    }
+    addValidators(validators) {
+        this.setValidators(addValidators(validators, this._rawValidators));
+    }
+    addAsyncValidators(validators) {
+        this.setAsyncValidators(addValidators(validators, this._rawAsyncValidators));
+    }
+    removeValidators(validators) {
+        this.setValidators(removeValidators(validators, this._rawValidators));
+    }
+    removeAsyncValidators(validators) {
+        this.setAsyncValidators(removeValidators(validators, this._rawAsyncValidators));
+    }
+    hasValidator(validator) {
+        return hasValidator(this._rawValidators, validator);
+    }
+    hasAsyncValidator(validator) {
+        return hasValidator(this._rawAsyncValidators, validator);
+    }
+    clearValidators() {
+        this.validator = null;
+    }
+    clearAsyncValidators() {
+        this.asyncValidator = null;
+    }
+    markAsDirty(onlySelf = false) {
+        this._pristine = false;
+        if (this._parent && !onlySelf) {
+            this._parent.markAsDirty(onlySelf);
+        }
+    }
+    markAsPristine(onlySelf = false) {
+        this._pristine = true;
+        this._forEachChild((control) => {
+            control.markAsPristine(true);
+        });
+        if (this._parent && !onlySelf) {
+            this._parent._updatePristine(onlySelf);
+        }
+    }
+    markAsPending(onlySelf = false) {
+        this._status = PENDING;
+        if (this._parent && !onlySelf) {
+            this._parent.markAsPending(onlySelf);
+        }
+    }
+    disable(onlySelf = false) {
+        // If parent has been marked artificially dirty we don't want to re-calculate the
+        // parent's dirtiness based on the children.
+        const skipPristineCheck = this._parentMarkedDirty(onlySelf);
+        this._status = DISABLED;
+        this._errors = null;
+        this._forEachChild((control) => {
+            control.disable(true);
+        });
+        this._updateAncestors(onlySelf, skipPristineCheck);
+    }
+    enable(onlySelf = false) {
+        // If parent has been marked artificially dirty we don't want to re-calculate the
+        // parent's dirtiness based on the children.
+        const skipPristineCheck = this._parentMarkedDirty(onlySelf);
+        this._status = VALID;
+        this._forEachChild((control) => {
+            control.enable(true);
+        });
+        this.updateValueAndValidity(true);
+        this._updateAncestors(onlySelf, skipPristineCheck);
+    }
+    setParent(parent) {
+        this._parent = parent;
+    }
+    setErrors(errors) {
+        this._errors = errors;
+        this._updateControlsErrors();
+    }
+    updateValueAndValidity(onlySelf = false) {
+        this._updateValue();
+        if (this.enabled) {
+            this._cancelExistingSubscription();
+            this._errors = this._runValidator();
+            this._status = this._calculateStatus();
+            if (this.status === VALID || this.status === PENDING) {
+                this._runAsyncValidator();
+            }
+        }
+        if (this._parent && !onlySelf) {
+            this._parent.updateValueAndValidity(onlySelf);
+        }
+    }
+    _anyControlsHaveStatus(status) {
+        return this._anyControls((control) => control.status === status);
+    }
+    _anyControlsDirty() {
+        return this._anyControls((control) => control.dirty);
+    }
+    _parentMarkedDirty(onlySelf) {
+        return !!(!onlySelf && this._parent && this._parent.dirty && !this._parent._anyControlsDirty());
+    }
+    _updatePristine(onlySelf = false) {
+        this._pristine = !this._anyControlsDirty();
+        if (this._parent && !onlySelf) {
+            this._parent._updatePristine(onlySelf);
+        }
+    }
+    _updateControlsErrors() {
+        this._status = this._calculateStatus();
+        if (this._parent) {
+            this._parent._updateControlsErrors();
+        }
+    }
+    _calculateStatus() {
+        if (this._allControlsDisabled())
+            return DISABLED;
+        if (this.errors)
+            return INVALID;
+        if (this._hasOwnPendingAsyncValidator || this._anyControlsHaveStatus(PENDING))
+            return PENDING;
+        if (this._anyControlsHaveStatus(INVALID))
+            return INVALID;
+        return VALID;
+    }
+    _updateAncestors(onlySelf, skipPristineCheck) {
+        if (this._parent && !onlySelf) {
+            this._parent.updateValueAndValidity(onlySelf);
+            if (!skipPristineCheck) {
+                this._parent._updatePristine();
+            }
+        }
+    }
+    _runValidator() {
+        return this.validator ? this.validator(this) : null;
+    }
+    _cancelExistingSubscription() {
+        if (this._asyncValidationSubscription) {
+            this._asyncValidationSubscription.unsubscribe();
+            this._hasOwnPendingAsyncValidator = false;
+        }
+    }
+    _runAsyncValidator() {
+        if (this.asyncValidator) {
+            this._status = PENDING;
+            this._hasOwnPendingAsyncValidator = true;
+            this._asyncValidationSubscription = from(this.asyncValidator(this)).subscribe((errors) => {
+                var _a, _b;
+                this._hasOwnPendingAsyncValidator = false;
+                // This will trigger the recalculation of the validation status, which depends on
+                // the state of the asynchronous validation (whether it is in progress or not). So, it is
+                // necessary that we have updated the `_hasOwnPendingAsyncValidator` boolean flag first.
+                this.setErrors(errors);
+                (_b = (_a = this.root)._emitChange) === null || _b === void 0 ? void 0 : _b.call(_a);
+            });
+        }
+    }
+}

package/form/model/form-control.d.ts

@@ -0,0 +1,23 @@
+import type { AsyncValidatorFn, FormControlStatus, ValidatorFn } from './types';
+import { AbstractControl } from './abstract-control';
+export interface FormControlState<V> {
+    value: V;
+    disabled?: boolean;
+}
+export declare class FormControl<V> extends AbstractControl<V> {
+    readonly defaultState: FormControlState<V> | V;
+    protected _value: V;
+    protected _status: FormControlStatus;
+    constructor(formState: FormControlState<V> | V, validators?: ValidatorFn | ValidatorFn[] | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    getError(errorCode: string): any;
+    hasError(errorCode: string): boolean;
+    setValue(value: V, onlySelf?: boolean): void;
+    patchValue(value: V, onlySelf?: boolean): void;
+    reset(formState?: V | FormControlState<V>, onlySelf?: boolean): void;
+    protected _updateValue(): void;
+    protected _forEachChild(): void;
+    protected _anyControls(): boolean;
+    protected _allControlsDisabled(): boolean;
+    protected _isFormStateObject(formState: FormControlState<V> | V): formState is FormControlState<V>;
+    private _applyFormState;
+}

package/form/model/form-control.js

@@ -0,0 +1,72 @@
+import { AbstractControl } from './abstract-control';
+import { VALID } from './vars';
+export class FormControl extends AbstractControl {
+    constructor(formState, validators, asyncValidator) {
+        super(validators !== null && validators !== void 0 ? validators : null, asyncValidator !== null && asyncValidator !== void 0 ? asyncValidator : null);
+        Object.defineProperty(this, "defaultState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_value", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_status", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: VALID
+        });
+        this.defaultState = formState;
+        this._applyFormState(formState);
+        this.updateValueAndValidity(true);
+    }
+    getError(errorCode) {
+        return this && this.errors ? this.errors[errorCode] : null;
+    }
+    hasError(errorCode) {
+        return !!this.getError(errorCode);
+    }
+    setValue(value, onlySelf) {
+        this._value = value;
+        this.updateValueAndValidity(onlySelf);
+    }
+    patchValue(value, onlySelf) {
+        this.setValue(value, onlySelf);
+    }
+    reset(formState = this.defaultState, onlySelf) {
+        this._applyFormState(formState);
+        this.markAsPristine(onlySelf);
+        this.setValue(this.value, onlySelf);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    _updateValue() { }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    _forEachChild() { }
+    _anyControls() {
+        return false;
+    }
+    _allControlsDisabled() {
+        return this.disabled;
+    }
+    _isFormStateObject(formState) {
+        return (typeof formState === 'object' &&
+            formState !== null &&
+            Object.keys(formState).length === 2 &&
+            'value' in formState &&
+            'disabled' in formState);
+    }
+    _applyFormState(formState) {
+        if (this._isFormStateObject(formState)) {
+            this._value = formState.value;
+            formState.disabled ? this.disable(true) : this.enable(true);
+        }
+        else {
+            this._value = formState;
+        }
+    }
+}

package/form/model/form-group.d.ts

@@ -0,0 +1,62 @@
+import type { AsyncValidatorFn, FormControlStatus, ValidatorFn } from './types';
+import { AbstractControl } from './abstract-control';
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+type GetFormControlPropertyFromArray<T, A> = Mutable<A> extends [infer K, ...infer R] ? K extends keyof T ? GetFormControlPropertyFromArray<T[K], R> : any : T;
+type GetFormControlProperty<T, S> = S extends `${infer K}.${infer R}` ? K extends keyof T ? GetFormControlProperty<T[K], R> : any : S extends keyof T ? T[S] : any;
+type GetFormGroupT<C extends FormGroup<any>> = C extends FormGroup<infer T> ? T : unknown;
+type GetFormGroupValue<T extends {
+    [K in keyof T]: AbstractControl;
+}> = {
+    [K in keyof T]?: T[K] extends FormGroup ? GetFormGroupValue<GetFormGroupT<T[K]>> : T[K]['value'];
+};
+export declare class FormGroup<T extends {
+    [K in keyof T]: AbstractControl;
+} = any> extends AbstractControl<{
+    [K in keyof T]: T[K]['value'];
+}> {
+    controls: T;
+    protected _value: {
+        [K in keyof T]: T[K]['value'];
+    };
+    protected _status: FormControlStatus;
+    constructor(controls: T, validators?: ValidatorFn | ValidatorFn[] | null, asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null);
+    get<S extends string>(path: S): AbstractControl<GetFormControlProperty<{
+        [K in keyof T]: T[K]['value'];
+    }, S>>;
+    get<S extends ArrayLike<string>>(path: S): AbstractControl<GetFormControlPropertyFromArray<{
+        [K in keyof T]: T[K]['value'];
+    }, S>>;
+    getError(errorCode: string, path?: string[] | string): any;
+    hasError(errorCode: string, path?: string[] | string): boolean;
+    addControl<K extends keyof T>(name: K, control: T[K]): void;
+    addControl(name: string, control: AbstractControl): void;
+    removeControl<K extends keyof T>(name: K): void;
+    removeControl(name: string): void;
+    setControl<K extends keyof T>(name: K, control: T[K]): void;
+    setControl(name: string, control: AbstractControl): void;
+    contains<K extends keyof T>(controlName: K): boolean;
+    contains(controlName: string): boolean;
+    setValue(value: {
+        [K in keyof T]: T[K]['value'];
+    } & {
+        [K: string]: any;
+    }, onlySelf?: boolean): void;
+    patchValue(value: GetFormGroupValue<T> & {
+        [K: string]: any;
+    }, onlySelf?: boolean): void;
+    reset(value?: GetFormGroupValue<T> & {
+        [K: string]: any;
+    }, onlySelf?: boolean): void;
+    protected _updateValue(): void;
+    protected _forEachChild(cb: (v: any, k: string) => void): void;
+    protected _anyControls(condition: (c: AbstractControl) => boolean): boolean;
+    protected _allControlsDisabled(): boolean;
+    private _setUpControls;
+    private _reduceValue;
+    private _reduceChildren;
+    private _checkAllValuesPresent;
+    private _throwIfControlMissing;
+}
+export {};