@microsoft/windows-admin-center-sdk/angular/esm2020/src/controls/form/form-field/form-field-async-validator.directive.mjs

Microsoft - Windows Admin Center Shell

import { Directive, EventEmitter, forwardRef, Inject, Input, Optional, Output, Self } from '@angular/core';
import { NG_ASYNC_VALIDATORS } from '@angular/forms';
import { forkJoin, of, Subject } from 'rxjs';
import { delay, map, mergeMap } from 'rxjs/operators';
import { FormAsyncValidatorBase } from '../validators/base-async-validator';
import { SME_ASYNC_VALIDATORS } from '../validators/sme-async-validator';
import * as i0 from "@angular/core";
/**
 * Provider for the FormFieldAsyncValidatorDirective directive
 */
export const FORM_FIELD_ASYNC_VALIDATOR = {
    provide: NG_ASYNC_VALIDATORS,
    useExisting: forwardRef(() => FormFieldAsyncValidatorDirective),
    multi: true
};
export const defaultAsyncValidationDebounceTime = 800;
/**
 * Implementation of Async Validator for sme-form-field
 * The selector for this directive must match @see FormFieldComponent.selector. see FormFieldComponent for details.
 */
export class FormFieldAsyncValidatorDirective extends FormAsyncValidatorBase {
    /**
     * Instantiates a new instance of FormFieldAsyncValidatorDirective
     */
    constructor(asyncValidators) {
        super();
        this.asyncValidators = asyncValidators;
        /**
         * EventEmitter for checking validation and raising alerts
         * Subscribers are expected to populate the 'alerts' map with their own validation alerts
         */
        this.customAsyncValidate = new EventEmitter();
        /**
         * Subject to emit when new alerts are available
         */
        this.asyncAlert = new Subject();
    }
    /**
     * Implementation of Validator interface.
     * Validates the value of this elements form control. Use the @see checkValidate event to hook into this function.
     * @param c The FormControl attached to this element
     * @return null when valid, otherwise returns a validation object in the form of "{ errorType: {valid: false} }".
     */
    validate(c) {
        const asyncAlerts = [];
        if (!this.customAsyncValidateDisabled) {
            // collect custom validation observables
            this.customAsyncValidate.emit({ formControl: c, alerts: asyncAlerts });
            // incorporate our super validation
            asyncAlerts.unshift(super.validate(c));
            // collect SmeValidator alerts
            if (this.asyncValidators && this.asyncValidators.length > 0) {
                const injectedAlerts = this.asyncValidators.map(validator => validator.validate(c));
                asyncAlerts.push(...injectedAlerts);
            }
            // determine our debounce time so that we dont fire to often
            let delayTime = defaultAsyncValidationDebounceTime;
            if (MsftSme.isNumber(this.customAsyncValidateDebounceTime) && this.customAsyncValidateDebounceTime >= 0) {
                delayTime = this.customAsyncValidateDebounceTime;
            }
            // delay all of our validators by the debounce time.
            // if the value changes in this time frame, the observable subscriptions are canceled and should cease.
            // we do this by injecting a delay in the pipeline before returning the original validation logic
            const debouncedAlerts = asyncAlerts.map(originalObservable => of(null).pipe(delay(delayTime), mergeMap(() => originalObservable)));
            return forkJoin(debouncedAlerts).pipe(map((recievedAlerts) => {
                const alerts = recievedAlerts.reduce((result, next) => ({ ...result, ...next }), {});
                // notify any listeners that we have alerts available
                this.asyncAlert.next(alerts);
                // get the errors list from the alerts. return that as our errors collection for angulars internal processing
                const errors = {};
                // pull out the error alerts to return to angular. Only these alerts should actually invalidate the control
                Object.keys(alerts).forEach(key => {
                    const alert = alerts[key];
                    if (!alert || !alert.valid) {
                        errors[key] = alert;
                    }
                });
                return this.alertsOrNull(errors);
            }));
        }
        return of(null);
    }
}
/** @nocollapse */ FormFieldAsyncValidatorDirective.ɵfac = function FormFieldAsyncValidatorDirective_Factory(t) { return new (t || FormFieldAsyncValidatorDirective)(i0.ɵɵdirectiveInject(SME_ASYNC_VALIDATORS, 10)); };
/** @nocollapse */ FormFieldAsyncValidatorDirective.ɵdir = /** @pureOrBreakMyCode */ i0.ɵɵdefineDirective({ type: FormFieldAsyncValidatorDirective, selectors: [["sme-form-field", "customAsyncValidate", ""]], inputs: { customAsyncValidateDisabled: "customAsyncValidateDisabled", customAsyncValidateDebounceTime: "customAsyncValidateDebounceTime" }, outputs: { customAsyncValidate: "customAsyncValidate" }, features: [i0.ɵɵProvidersFeature([FORM_FIELD_ASYNC_VALIDATOR]), i0.ɵɵInheritDefinitionFeature] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FormFieldAsyncValidatorDirective, [{
        type: Directive,
        args: [{
                // eslint-disable-next-line @angular-eslint/directive-selector
                selector: 'sme-form-field[customAsyncValidate]',
                providers: [FORM_FIELD_ASYNC_VALIDATOR]
            }]
    }], function () { return [{ type: Array, decorators: [{
                type: Optional
            }, {
                type: Self
            }, {
                type: Inject,
                args: [SME_ASYNC_VALIDATORS]
            }] }]; }, { customAsyncValidateDisabled: [{
            type: Input
        }], customAsyncValidateDebounceTime: [{
            type: Input
        }], customAsyncValidate: [{
            type: Output
        }] }); })();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-field-async-validator.directive.js","sourceRoot":"","sources":["../../../../../../../../../angular/src/controls/form/form-field/form-field-async-validator.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EventEmitter, forwardRef, Inject, Input, Optional, Output, Self, StaticProvider } from '@angular/core';\r\nimport { AsyncValidator, FormControl, NG_ASYNC_VALIDATORS, ValidationErrors } from '@angular/forms';\r\nimport { forkJoin, Observable, of, Subject } from 'rxjs';\r\nimport { delay, map, mergeMap } from 'rxjs/operators';\r\nimport { AsyncValidationAlerts, ValidationAlert, ValidationAlerts } from '../validation-alert/validation-alert';\r\nimport { FormAsyncValidatorBase } from '../validators/base-async-validator';\r\nimport { SmeAsyncValidator, SME_ASYNC_VALIDATORS } from '../validators/sme-async-validator';\r\n\r\n/**\r\n * Arguments for the @see FormFieldAsyncValidatorDirective.customAsyncValidate Output event\r\n */\r\nexport interface CheckAsyncValidationEventArgs {\r\n    /**\r\n     * The form control that we are validating\r\n     */\r\n    formControl: FormControl;\r\n\r\n    /**\r\n     * An observable that emits an alert object when complete\r\n     */\r\n    alerts: AsyncValidationAlerts;\r\n}\r\n\r\n/**\r\n * Provider for the FormFieldAsyncValidatorDirective directive\r\n */\r\nexport const FORM_FIELD_ASYNC_VALIDATOR: StaticProvider = {\r\n    provide: NG_ASYNC_VALIDATORS,\r\n    useExisting: forwardRef(() => FormFieldAsyncValidatorDirective),\r\n    multi: true\r\n};\r\n\r\nexport const defaultAsyncValidationDebounceTime = 800;\r\n\r\n/**\r\n * Implementation of Async Validator for sme-form-field\r\n * The selector for this directive must match @see FormFieldComponent.selector. see FormFieldComponent for details.\r\n */\r\n@Directive({\r\n    // eslint-disable-next-line @angular-eslint/directive-selector\r\n    selector: 'sme-form-field[customAsyncValidate]',\r\n    providers: [FORM_FIELD_ASYNC_VALIDATOR]\r\n})\r\nexport class FormFieldAsyncValidatorDirective extends FormAsyncValidatorBase implements AsyncValidator {\r\n\r\n    @Input()\r\n    /**\r\n     * It indicates whether to disable this validator.\r\n     * In some scenarios we want to programmatically control whether this validator\r\n     * should be used like in schema driven form.\r\n     * Then this property will be used.\r\n     */\r\n    public customAsyncValidateDisabled: boolean;\r\n\r\n    @Input()\r\n    public customAsyncValidateDebounceTime: number;\r\n\r\n    /**\r\n     * EventEmitter for checking validation and raising alerts\r\n     * Subscribers are expected to populate the 'alerts' map with their own validation alerts\r\n     */\r\n    @Output()\r\n    public customAsyncValidate: EventEmitter<CheckAsyncValidationEventArgs> = new EventEmitter<CheckAsyncValidationEventArgs>();\r\n\r\n    /**\r\n     * Subject to emit when new alerts are available\r\n     */\r\n    public asyncAlert = new Subject<ValidationAlerts>();\r\n\r\n    /**\r\n     * Instantiates a new instance of FormFieldAsyncValidatorDirective\r\n     */\r\n    constructor(\r\n        @Optional() @Self() @Inject(SME_ASYNC_VALIDATORS) private asyncValidators: Array<SmeAsyncValidator>) {\r\n        super();\r\n    }\r\n\r\n    /**\r\n     * Implementation of Validator interface.\r\n     * Validates the value of this elements form control. Use the @see checkValidate event to hook into this function.\r\n     * @param c The FormControl attached to this element\r\n     * @return null when valid, otherwise returns a validation object in the form of \"{ errorType: {valid: false} }\".\r\n     */\r\n    public validate(c: FormControl): Observable<ValidationErrors | null> {\r\n        const asyncAlerts: AsyncValidationAlerts = [];\r\n\r\n        if (!this.customAsyncValidateDisabled) {\r\n            // collect custom validation observables\r\n            this.customAsyncValidate.emit({ formControl: c, alerts: asyncAlerts });\r\n\r\n            // incorporate our super validation\r\n            asyncAlerts.unshift(super.validate(c));\r\n\r\n            // collect SmeValidator alerts\r\n            if (this.asyncValidators && this.asyncValidators.length > 0) {\r\n                const injectedAlerts = this.asyncValidators.map(validator => validator.validate(c));\r\n                asyncAlerts.push(...injectedAlerts);\r\n            }\r\n\r\n            // determine our debounce time so that we dont fire to often\r\n            let delayTime = defaultAsyncValidationDebounceTime;\r\n            if (MsftSme.isNumber(this.customAsyncValidateDebounceTime) && this.customAsyncValidateDebounceTime >= 0) {\r\n                delayTime = this.customAsyncValidateDebounceTime;\r\n            }\r\n\r\n            // delay all of our validators by the debounce time.\r\n            // if the value changes in this time frame, the observable subscriptions are canceled and should cease.\r\n            // we do this by injecting a delay in the pipeline before returning the original validation logic\r\n            const debouncedAlerts = asyncAlerts.map(\r\n                originalObservable => of(null).pipe(\r\n                    delay(delayTime),\r\n                    mergeMap(() => originalObservable))\r\n            );\r\n\r\n            return forkJoin(debouncedAlerts).pipe(\r\n                map((recievedAlerts) => {\r\n                    const alerts = recievedAlerts.reduce((result, next) => ({ ...result, ...next }), <ValidationAlerts>{});\r\n                    // notify any listeners that we have alerts available\r\n                    this.asyncAlert.next(alerts);\r\n\r\n                    // get the errors list from the alerts. return that as our errors collection for angulars internal processing\r\n                    const errors: ValidationAlerts = {};\r\n\r\n                    // pull out the error alerts to return to angular. Only these alerts should actually invalidate the control\r\n                    Object.keys(alerts).forEach(key => {\r\n                        const alert = alerts[key];\r\n                        if (!alert || !(<ValidationAlert>alert).valid) {\r\n                            errors[key] = alert;\r\n                        }\r\n                    });\r\n\r\n                    return this.alertsOrNull(errors);\r\n                })\r\n            );\r\n        }\r\n\r\n        return of(null);\r\n    }\r\n}\r\n"]}