@anglr/common 8.0.0 → 10.0.0-beta.20220215124944

package/date-fns/dist/es2015/forms/src/services/validationErrorRenderer/validationErrorRenderer.interface.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: forms/src/services/validationErrorRenderer/validationErrorRenderer.interface.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Describes function that is used for performing actions when form is submitted or dirty
+ * @record
+ */
+export function IsSubmittedOrDirtyFunc() { }
+/**
+ * Component that is used for rendering validation errors
+ * @record
+ */
+export function ValidationErrorsComponent() { }
+if (false) {
+    /**
+     * Shows validation errors in component
+     * @param {?} errors - Errors to be shown, or null if to be hidden
+     * @return {?}
+     */
+    ValidationErrorsComponent.prototype.show = function (errors) { };
+}
+/**
+ * Context passed to template that is used for rendering validation errors
+ * @record
+ */
+export function ValidationErrorsTemplateContext() { }
+if (false) {
+    /**
+     * Errors to be shown
+     * @type {?}
+     */
+    ValidationErrorsTemplateContext.prototype.$implicit;
+}
+/**
+ * Options for ValidationErrorRenderer
+ * @record
+ */
+export function ValidationErrorsRendererOptions() { }
+if (false) {
+    /**
+     * Prefix of css classes applied to element
+     * @type {?|undefined}
+     */
+    ValidationErrorsRendererOptions.prototype.prefix;
+    /**
+     * Suffix of css classes applied to element
+     * @type {?|undefined}
+     */
+    ValidationErrorsRendererOptions.prototype.suffix;
+    /**
+     * Css class attached to wrapper div
+     * @type {?|undefined}
+     */
+    ValidationErrorsRendererOptions.prototype.wrapperDivClass;
+    /**
+     * Component used for rendering validation errors
+     * @type {?|undefined}
+     */
+    ValidationErrorsRendererOptions.prototype.component;
+    /**
+     * Template used for rendering validation errors
+     * @type {?|undefined}
+     */
+    ValidationErrorsRendererOptions.prototype.template;
+}
+/**
+ * Options for ValidationErrorRendererFactory
+ * @record
+ */
+export function ValidationErrorRendererFactoryOptions() { }
+if (false) {
+    /**
+     * Type of ValidationErrorRenderer implementation
+     * @type {?|undefined}
+     */
+    ValidationErrorRendererFactoryOptions.prototype.rendererType;
+}
+/**
+ * Describes type that represents ValidationErrorRenderer
+ * @record
+ */
+export function ValidationErrorRendererCtor() { }
+/**
+ * Describes service that is used for rendering validation errors
+ * @record
+ */
+export function ValidationErrorRenderer() { }
+if (false) {
+    /**
+     * Html element that is wrapping errors
+     * @type {?}
+     */
+    ValidationErrorRenderer.prototype.wrapperElement;
+    /**
+     * Destroys renderer and everything that was rendered
+     * @return {?}
+     */
+    ValidationErrorRenderer.prototype.destroy = function () { };
+    /**
+     * Updates rendered errors for current state and returns true if errors were rendered, otherwise false
+     * @param {?=} errorMessages - Object storing error messages to be used as override
+     * @param {?=} onlyShow - Indication that update performs only displaying of existing errors
+     * @return {?}
+     */
+    ValidationErrorRenderer.prototype.update = function (errorMessages, onlyShow) { };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/date-fns/dist/es2015/forms/src/services/validationErrorRenderer/validationErrorRenderer.service.js

@@ -0,0 +1,371 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: forms/src/services/validationErrorRenderer/validationErrorRenderer.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable, Inject, InjectionToken, Optional, ComponentFactoryResolver, ApplicationRef } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { extend } from '@jscrpt/common';
+import { ErrorMessagesExtractor } from '../errorMessagesExtractor/errorMessagesExtractor.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../errorMessagesExtractor/errorMessagesExtractor.service";
+import * as i2 from "@angular/common";
+/**
+ * Injection token used for injecting global options for ValidationErrorRendererFactory
+ * @type {?}
+ */
+export const VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS = new InjectionToken("VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS");
+/**
+ * Service used for creating validation errors renderer
+ */
+export class ValidationErrorRendererFactory {
+    //######################### constructor #########################
+    /**
+     * @param {?} _errorMessagesExtractor
+     * @param {?} _document
+     * @param {?} options
+     */
+    constructor(_errorMessagesExtractor, _document, options) {
+        this._errorMessagesExtractor = _errorMessagesExtractor;
+        this._document = _document;
+        this._options = extend(true, {}, DEFAULT_OPTIONS, options);
+    }
+    //######################### public methods #########################
+    /**
+     * Creates new instance of ValidationErrorRenderer
+     * @param {?} control - Control that is being processed for errors
+     * @param {?} controlElement - Html element that represents control that is being processed
+     * @param {?} injector
+     * @param {?} isSubmittedOrDirty - Function used for testing if control is submitted or dirty
+     * @param {?} options - Options for validation errors renderer factory
+     * @return {?}
+     */
+    create(control, controlElement, injector, isSubmittedOrDirty, options) {
+        /** @type {?} */
+        let opts = extend(true, {}, this._options, options);
+        return new opts.rendererType(this._errorMessagesExtractor, control, controlElement, this._document, injector, isSubmittedOrDirty, opts);
+    }
+}
+/** @nocollapse */ ValidationErrorRendererFactory.ɵprov = i0.ɵɵdefineInjectable({ factory: function ValidationErrorRendererFactory_Factory() { return new ValidationErrorRendererFactory(i0.ɵɵinject(i1.ErrorMessagesExtractor), i0.ɵɵinject(i2.DOCUMENT), i0.ɵɵinject(VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS, 8)); }, token: ValidationErrorRendererFactory, providedIn: "root" });
+ValidationErrorRendererFactory.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+ValidationErrorRendererFactory.ctorParameters = () => [
+    { type: ErrorMessagesExtractor },
+    { type: HTMLDocument, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS,] }] }
+];
+if (false) {
+    /**
+     * Options for validation error renderer factory
+     * @type {?}
+     * @protected
+     */
+    ValidationErrorRendererFactory.prototype._options;
+    /**
+     * @type {?}
+     * @protected
+     */
+    ValidationErrorRendererFactory.prototype._errorMessagesExtractor;
+    /**
+     * @type {?}
+     * @protected
+     */
+    ValidationErrorRendererFactory.prototype._document;
+}
+/**
+ * Default implementation of validation error renderer
+ */
+export class DefaultValidationErrorRenderer {
+    //######################### constructor #########################
+    /**
+     * @param {?} _errorMessagesExtractor
+     * @param {?} _control
+     * @param {?} _controlElement
+     * @param {?} _document
+     * @param {?} _injector
+     * @param {?} _isSubmittedOrDirty
+     * @param {?} _options
+     */
+    constructor(_errorMessagesExtractor, _control, _controlElement, _document, _injector, _isSubmittedOrDirty, _options) {
+        this._errorMessagesExtractor = _errorMessagesExtractor;
+        this._control = _control;
+        this._controlElement = _controlElement;
+        this._document = _document;
+        this._injector = _injector;
+        this._isSubmittedOrDirty = _isSubmittedOrDirty;
+        this._options = _options;
+        this._initialize();
+    }
+    //######################### public methods - implementation of ValiDationErrorRenderer #########################
+    /**
+     * Destroys renderer and everything that was rendered
+     * @return {?}
+     */
+    destroy() {
+        var _a;
+        if (this._component) {
+            this._injector.get(ApplicationRef).detachView(this._component.hostView);
+            this._component.destroy();
+            this._component = null;
+        }
+        (_a = this.wrapperElement) === null || _a === void 0 ? void 0 : _a.remove();
+        this.wrapperElement = null;
+    }
+    /**
+     * Updates rendered errors for current state and returns true if errors were rendered, otherwise false
+     * @param {?=} errorMessages - Object storing error messages to be used as override
+     * @param {?=} onlyShow - Indication that update performs only displaying of existing errors
+     * @return {?}
+     */
+    update(errorMessages, onlyShow = false) {
+        /** @type {?} */
+        let result = false;
+        if (onlyShow) {
+            this._isSubmittedOrDirty((/**
+             * @return {?}
+             */
+            () => {
+                this._show();
+                this._toggleErrors();
+                result = true;
+            }), (/**
+             * @return {?}
+             */
+            () => {
+                this._hide();
+                result = false;
+            }), !!this._lastErrors);
+            return result;
+        }
+        //hides old errors
+        this._toggleErrors(false);
+        this._lastErrors = this._errorMessagesExtractor.getErrors(this._control, errorMessages);
+        if (this._lastErrors) {
+            this._isSubmittedOrDirty((/**
+             * @return {?}
+             */
+            () => {
+                this._show();
+                result = true;
+                this._toggleErrors();
+            }), (/**
+             * @return {?}
+             */
+            () => {
+                this._hide();
+                result = false;
+            }));
+        }
+        else {
+            this._hide();
+            result = false;
+        }
+        return result;
+    }
+    //######################### protected methods #########################
+    /**
+     * Toggles css classes for errors that are currently set
+     * @protected
+     * @param {?=} add - Indication whether add or remove errors
+     * @return {?}
+     */
+    _toggleErrors(add = true) {
+        if (!this._lastErrors) {
+            return;
+        }
+        /** @type {?} */
+        let errorsClasses = this._lastErrors.errors.map((/**
+         * @param {?} error
+         * @return {?}
+         */
+        error => `${this._options.prefix}${error.toLowerCase()}${this._options.suffix}`));
+        (add ? this._controlElement.classList.add : this._controlElement.classList.remove).apply(this._controlElement.classList, errorsClasses);
+        (add ? this.wrapperElement.classList.add : this.wrapperElement.classList.remove).apply(this.wrapperElement.classList, errorsClasses);
+        this._errorMessageAttr.value = (add ? this._lastErrors.errorMessages : [])
+            .join(' ');
+        this._render(add);
+    }
+    /**
+     * Initialize renderer
+     * @protected
+     * @return {?}
+     */
+    _initialize() {
+        this.wrapperElement = this._document.createElement('div');
+        this._hide();
+        this.wrapperElement.classList.add(this._options.wrapperDivClass);
+        this._errorMessageAttr = this._document.createAttribute('data-error-message');
+        this.wrapperElement.attributes.setNamedItem(this._errorMessageAttr);
+        this._controlElement.after(this.wrapperElement);
+    }
+    /**
+     * Renders error messages
+     * @protected
+     * @param {?} add - Indication whether add or remove errors
+     * @return {?}
+     */
+    _render(add) {
+        if (this._options.component) {
+            this._renderComponent(add);
+        }
+        else if (this._options.template) {
+            this._renderTemplate(add);
+        }
+        else {
+            this._renderDivs(add);
+        }
+    }
+    /**
+     * Renders divs with errors
+     * @protected
+     * @param {?=} add - Indication whether add or remove errors
+     * @return {?}
+     */
+    _renderDivs(add = true) {
+        var _a, _b;
+        if (!add) {
+            /** @type {?} */
+            let children = this.wrapperElement.children;
+            //first clean old messages
+            for (let x = children.length - 1; x >= 0; x--) {
+                children.item(x).remove();
+            }
+            return;
+        }
+        if ((_b = (_a = this._lastErrors) === null || _a === void 0 ? void 0 : _a.errorMessages) === null || _b === void 0 ? void 0 : _b.length) {
+            this._lastErrors.errorMessages.forEach((/**
+             * @param {?} message
+             * @return {?}
+             */
+            message => {
+                /** @type {?} */
+                let errorDiv = this._document.createElement('div');
+                errorDiv.innerText = message;
+                this.wrapperElement.append(errorDiv);
+            }));
+        }
+    }
+    /**
+     * Renders component with errors
+     * @protected
+     * @param {?=} add - Indication whether add or remove errors
+     * @return {?}
+     */
+    _renderComponent(add = true) {
+        if (add) {
+            //render component
+            if (!this._component) {
+                // 1. Create a component reference from the component 
+                this._component = this._injector.get(ComponentFactoryResolver)
+                    .resolveComponentFactory(this._options.component)
+                    .create(this._injector);
+                // 2. Attach component to the appRef so that it's inside the ng component tree
+                this._injector.get(ApplicationRef).attachView(this._component.hostView);
+                // 3. Get DOM element from component
+                /** @type {?} */
+                const domElem = (/** @type {?} */ (((/** @type {?} */ (this._component.hostView)))
+                    .rootNodes[0]));
+                // 4. Append DOM element to the body
+                this.wrapperElement.append(domElem);
+            }
+            this._component.instance.show(this._lastErrors);
+        }
+        else if (this._component) {
+            this._component.instance.show(null);
+        }
+    }
+    /**
+     * Renders template with errors
+     * @protected
+     * @param {?=} _add
+     * @return {?}
+     */
+    _renderTemplate(_add = true) {
+    }
+    /**
+     * Shows wrapper element
+     * @protected
+     * @return {?}
+     */
+    _show() {
+        this.wrapperElement.style.display = 'block';
+    }
+    /**
+     * Hides wrapper element
+     * @protected
+     * @return {?}
+     */
+    _hide() {
+        this.wrapperElement.style.display = 'none';
+    }
+}
+if (false) {
+    /**
+     * Html element attribute storing error messages
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._errorMessageAttr;
+    /**
+     * Object storing last obtained errors
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._lastErrors;
+    /**
+     * Component used for displaying errors
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._component;
+    /**
+     * Html element that is wrapping errors
+     * @type {?}
+     */
+    DefaultValidationErrorRenderer.prototype.wrapperElement;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._errorMessagesExtractor;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._control;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._controlElement;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._document;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._injector;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._isSubmittedOrDirty;
+    /**
+     * @type {?}
+     * @protected
+     */
+    DefaultValidationErrorRenderer.prototype._options;
+}
+/** @type {?} */
+const DEFAULT_OPTIONS = {
+    prefix: 'ng-',
+    suffix: '-error',
+    wrapperDivClass: 'validation-error-div',
+    rendererType: DefaultValidationErrorRenderer
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validationErrorRenderer.service.js","sourceRoot":"","sources":["../../../../../../../forms/src/services/validationErrorRenderer/validationErrorRenderer.service.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,QAAQ,EAAY,wBAAwB,EAAE,cAAc,EAAgC,MAAM,eAAe,CAAC;AAE9J,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAC,MAAM,EAAmB,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAC,sBAAsB,EAAC,MAAM,0DAA0D,CAAC;;;;;;;;AAOhG,MAAM,OAAO,yCAAyC,GAA0D,IAAI,cAAc,CAAwC,2CAA2C,CAAC;;;;AAMtN,MAAM,OAAO,8BAA8B;;;;;;;IAUvC,YAAsB,uBAA+C,EAC7B,SAAuB,EACY,OAA8C;QAFnG,4BAAuB,GAAvB,uBAAuB,CAAwB;QAC7B,cAAS,GAAT,SAAS,CAAc;QAG3D,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;;;;;;;;;;;IAWM,MAAM,CAAC,OAAoB,EACpB,cAA2B,EAC3B,QAAkB,EAClB,kBAA0C,EAC1C,OAA8C;;YAEpD,IAAI,GAA0C,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;QAE1F,OAAO,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,uBAAuB,EAC5B,OAAO,EACP,cAAc,EACd,IAAI,CAAC,SAAS,EACd,QAAQ,EACR,kBAAkB,EAClB,IAAI,CAAC,CAAC;IACvC,CAAC;;;;YA1CJ,UAAU,SAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;;;YAZxB,sBAAsB;YAwByB,YAAY,uBAAlD,MAAM,SAAC,QAAQ;4CACf,QAAQ,YAAI,MAAM,SAAC,yCAAyC;;;;;;;;IALzE,kDAA0D;;;;;IAG9C,iEAAyD;;;;;IACzD,mDAAmD;;;;;AAoCnE,MAAM,OAAO,8BAA8B;;;;;;;;;;;IA2BvC,YAAsB,uBAA+C,EAC/C,QAAqB,EACrB,eAA4B,EAC5B,SAAuB,EACvB,SAAmB,EACnB,mBAA2C,EAC3C,QAAyC;QANzC,4BAAuB,GAAvB,uBAAuB,CAAwB;QAC/C,aAAQ,GAAR,QAAQ,CAAa;QACrB,oBAAe,GAAf,eAAe,CAAa;QAC5B,cAAS,GAAT,SAAS,CAAc;QACvB,cAAS,GAAT,SAAS,CAAU;QACnB,wBAAmB,GAAnB,mBAAmB,CAAwB;QAC3C,aAAQ,GAAR,QAAQ,CAAiC;QAE3D,IAAI,CAAC,WAAW,EAAE,CAAC;IACvB,CAAC;;;;;;IAOM,OAAO;;QAEV,IAAG,IAAI,CAAC,UAAU,EAClB;YACI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;YACxE,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;YAC1B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SAC1B;QAED,MAAA,IAAI,CAAC,cAAc,0CAAE,MAAM,GAAG;QAC9B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;IAC/B,CAAC;;;;;;;IAOM,MAAM,CAAC,aAAgC,EAAE,WAAoB,KAAK;;YAEjE,MAAM,GAAG,KAAK;QAElB,IAAG,QAAQ,EACX;YACI,IAAI,CAAC,mBAAmB;;;YAAC,GAAG,EAAE;gBAED,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,IAAI,CAAC,aAAa,EAAE,CAAC;gBACrB,MAAM,GAAG,IAAI,CAAA;YACjB,CAAC;;;YACD,GAAG,EAAE;gBAED,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,MAAM,GAAG,KAAK,CAAA;YAClB,CAAC,GACD,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAE7C,OAAO,MAAM,CAAC;SACjB;QAED,kBAAkB;QAClB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAExF,IAAG,IAAI,CAAC,WAAW,EACnB;YACI,IAAI,CAAC,mBAAmB;;;YAAC,GAAG,EAAE;gBAED,IAAI,CAAC,KAAK,EAAE,CAAC;gBACb,MAAM,GAAG,IAAI,CAAC;gBACd,IAAI,CAAC,aAAa,EAAE,CAAC;YACzB,CAAC;;;YACD,GAAG,EAAE;gBAEF,IAAI,CAAC,KAAK,EAAE,CAAC;gBACZ,MAAM,GAAG,KAAK,CAAC;YACnB,CAAC,EAAC,CAAC;SAC/B;aAED;YACI,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,MAAM,GAAG,KAAK,CAAC;SAClB;QAED,OAAO,MAAM,CAAC;IAClB,CAAC;;;;;;;;IAQS,aAAa,CAAC,MAAe,IAAI;QAEvC,IAAG,CAAC,IAAI,CAAC,WAAW,EACpB;YACI,OAAO;SACV;;YAEG,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG;;;;QAAC,KAAK,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,KAAK,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAC;QAEhI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QACxI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;QAErI,IAAI,CAAC,iBAAiB,CAAC,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC;aACrE,IAAI,CAAC,GAAG,CAAC,CAAC;QAEf,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;;;;;;IAKS,WAAW;QAEjB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1D,IAAI,CAAC,KAAK,EAAE,CAAC;QACb,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC;QAEjE,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC;QAE9E,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACpE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;IACpD,CAAC;;;;;;;IAMS,OAAO,CAAC,GAAY;QAE1B,IAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,EAC1B;YACI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;SAC9B;aACI,IAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAC9B;YACI,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;SAC7B;aAED;YACI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;SACzB;IACL,CAAC;;;;;;;IAMS,WAAW,CAAC,MAAe,IAAI;;QAErC,IAAG,CAAC,GAAG,EACP;;gBACQ,QAAQ,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ;YAE3C,0BAA0B;YAC1B,KAAI,IAAI,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAC5C;gBACI,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;aAC7B;YAED,OAAO;SACV;QAED,gBAAG,IAAI,CAAC,WAAW,0CAAE,aAAa,0CAAE,MAAM,EAC1C;YACI,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO;;;;YAAC,OAAO,CAAC,EAAE;;oBAEzC,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,KAAK,CAAC;gBAElD,QAAQ,CAAC,SAAS,GAAG,OAAO,CAAC;gBAE7B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACzC,CAAC,EAAC,CAAC;SACN;IACL,CAAC;;;;;;;IAMS,gBAAgB,CAAC,MAAe,IAAI;QAE1C,IAAG,GAAG,EACN;YACI,kBAAkB;YAClB,IAAG,CAAC,IAAI,CAAC,UAAU,EACnB;gBACI,sDAAsD;gBACtD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,wBAAwB,CAAC;qBACzD,uBAAuB,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;qBAChD,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAE5B,8EAA8E;gBAC9E,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;;;sBAGlE,OAAO,GAAG,mBAAA,CAAC,mBAAA,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAwB,CAAC;qBAC7D,SAAS,CAAC,CAAC,CAAC,EAAe;gBAEhC,oCAAoC;gBACpC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;aACvC;YAED,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;SACnD;aACI,IAAG,IAAI,CAAC,UAAU,EACvB;YACI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACvC;IACL,CAAC;;;;;;;IAMS,eAAe,CAAC,OAAgB,IAAI;IAG9C,CAAC;;;;;;IAKS,KAAK;QAEX,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,OAAO,GAAG,OAAO,CAAC;IAChD,CAAC;;;;;;IAKS,KAAK;QAEX,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC;IAC/C,CAAC;CACJ;;;;;;;IA7PG,2DAAkC;;;;;;IAKlC,qDAA8C;;;;;;IAK9C,oDAA8D;;;;;IAO9D,wDAAmC;;;;;IAGvB,iEAAyD;;;;;IACzD,kDAA+B;;;;;IAC/B,yDAAsC;;;;;IACtC,mDAAiC;;;;;IACjC,mDAA6B;;;;;IAC7B,6DAAqD;;;;;IACrD,kDAAmD;;;MAqO7D,eAAe,GACrB;IACI,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,QAAQ;IAChB,eAAe,EAAE,sBAAsB;IACvC,YAAY,EAAE,8BAA8B;CAC/C","sourcesContent":["import {Injectable, Inject, InjectionToken, Optional, Injector, ComponentFactoryResolver, ApplicationRef, EmbeddedViewRef, ComponentRef} from '@angular/core';\r\nimport {FormControl} from '@angular/forms';\r\nimport {DOCUMENT} from '@angular/common';\r\nimport {extend, StringDictionary} from '@jscrpt/common';\r\n\r\nimport {ErrorMessagesExtractor} from '../errorMessagesExtractor/errorMessagesExtractor.service';\r\nimport {ValidationErrorRenderer, IsSubmittedOrDirtyFunc, ValidationErrorsRendererOptions, ValidationErrorRendererFactoryOptions, ValidationErrorsComponent} from './validationErrorRenderer.interface';\r\nimport {ValidationErrorsResult} from '../errorMessagesExtractor/errorMessagesExtractor.interface';\r\n\r\n/**\r\n * Injection token used for injecting global options for ValidationErrorRendererFactory\r\n */\r\nexport const VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS: InjectionToken<ValidationErrorRendererFactoryOptions> = new InjectionToken<ValidationErrorRendererFactoryOptions>(\"VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS\");\r\n\r\n/**\r\n * Service used for creating validation errors renderer\r\n */\r\n@Injectable({providedIn: 'root'})\r\nexport class ValidationErrorRendererFactory\r\n{\r\n    //######################### protected fields #########################\r\n\r\n    /**\r\n     * Options for validation error renderer factory\r\n     */\r\n    protected _options: ValidationErrorRendererFactoryOptions;\r\n\r\n    //######################### constructor #########################\r\n    constructor(protected _errorMessagesExtractor: ErrorMessagesExtractor,\r\n                @Inject(DOCUMENT) protected _document: HTMLDocument,\r\n                @Optional() @Inject(VALIDATION_ERROR_RENDERER_FACTORY_OPTIONS) options: ValidationErrorRendererFactoryOptions)\r\n    {\r\n        this._options = extend(true, {}, DEFAULT_OPTIONS, options);\r\n    }\r\n\r\n    //######################### public methods #########################\r\n\r\n    /**\r\n     * Creates new instance of ValidationErrorRenderer\r\n     * @param control - Control that is being processed for errors\r\n     * @param controlElement - Html element that represents control that is being processed\r\n     * @param isSubmittedOrDirty - Function used for testing if control is submitted or dirty\r\n     * @param options - Options for validation errors renderer factory\r\n     */\r\n    public create(control: FormControl,\r\n                  controlElement: HTMLElement,\r\n                  injector: Injector,\r\n                  isSubmittedOrDirty: IsSubmittedOrDirtyFunc,\r\n                  options: ValidationErrorRendererFactoryOptions): ValidationErrorRenderer\r\n    {\r\n        let opts: ValidationErrorRendererFactoryOptions = extend(true, {}, this._options, options);\r\n\r\n        return new opts.rendererType(this._errorMessagesExtractor,\r\n                                     control,\r\n                                     controlElement,\r\n                                     this._document,\r\n                                     injector,\r\n                                     isSubmittedOrDirty,\r\n                                     opts);\r\n    }\r\n}\r\n\r\n/**\r\n * Default implementation of validation error renderer\r\n */\r\nexport class DefaultValidationErrorRenderer implements ValidationErrorRenderer\r\n{\r\n    //######################### protected fields #########################\r\n\r\n    /**\r\n     * Html element attribute storing error messages\r\n     */\r\n    protected _errorMessageAttr: Attr;\r\n\r\n    /**\r\n     * Object storing last obtained errors\r\n     */\r\n    protected _lastErrors: ValidationErrorsResult;\r\n\r\n    /**\r\n     * Component used for displaying errors\r\n     */\r\n    protected _component: ComponentRef<ValidationErrorsComponent>;\r\n\r\n    //######################### public properties - implementation of ValidationErrorRenderer #########################\r\n\r\n    /**\r\n     * Html element that is wrapping errors\r\n     */\r\n    public wrapperElement: HTMLElement;\r\n\r\n    //######################### constructor #########################\r\n    constructor(protected _errorMessagesExtractor: ErrorMessagesExtractor,\r\n                protected _control: FormControl,\r\n                protected _controlElement: HTMLElement,\r\n                protected _document: HTMLDocument,\r\n                protected _injector: Injector,\r\n                protected _isSubmittedOrDirty: IsSubmittedOrDirtyFunc,\r\n                protected _options: ValidationErrorsRendererOptions)\r\n    {\r\n        this._initialize();\r\n    }\r\n\r\n    //######################### public methods - implementation of ValiDationErrorRenderer #########################\r\n\r\n    /**\r\n     * Destroys renderer and everything that was rendered\r\n     */\r\n    public destroy(): void\r\n    {\r\n        if(this._component)\r\n        {\r\n            this._injector.get(ApplicationRef).detachView(this._component.hostView);\r\n            this._component.destroy();\r\n            this._component = null;\r\n        }\r\n\r\n        this.wrapperElement?.remove();\r\n        this.wrapperElement = null;\r\n    }\r\n\r\n    /**\r\n     * Updates rendered errors for current state and returns true if errors were rendered, otherwise false\r\n     * @param errorMessages - Object storing error messages to be used as override\r\n     * @param onlyShow - Indication that update performs only displaying of existing errors\r\n     */\r\n    public update(errorMessages?: StringDictionary, onlyShow: boolean = false): boolean\r\n    {\r\n        let result = false;\r\n\r\n        if(onlyShow)\r\n        {\r\n            this._isSubmittedOrDirty(() =>\r\n                                     {\r\n                                         this._show();\r\n                                         this._toggleErrors();\r\n                                         result = true\r\n                                     },\r\n                                     () =>\r\n                                     {\r\n                                         this._hide();\r\n                                         result = false\r\n                                     },\r\n                                     !!this._lastErrors);\r\n\r\n            return result;\r\n        }\r\n\r\n        //hides old errors\r\n        this._toggleErrors(false);\r\n        this._lastErrors = this._errorMessagesExtractor.getErrors(this._control, errorMessages);\r\n\r\n        if(this._lastErrors)\r\n        {\r\n            this._isSubmittedOrDirty(() =>\r\n                                     {\r\n                                         this._show();\r\n                                         result = true;\r\n                                         this._toggleErrors();\r\n                                     },\r\n                                     () =>\r\n                                     {\r\n                                        this._hide();\r\n                                         result = false;\r\n                                     });\r\n        }\r\n        else\r\n        {\r\n            this._hide();\r\n            result = false;\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    //######################### protected methods #########################\r\n\r\n    /**\r\n     * Toggles css classes for errors that are currently set\r\n     * @param add - Indication whether add or remove errors\r\n     */\r\n    protected _toggleErrors(add: boolean = true)\r\n    {\r\n        if(!this._lastErrors)\r\n        {\r\n            return;\r\n        }\r\n\r\n        let errorsClasses = this._lastErrors.errors.map(error => `${this._options.prefix}${error.toLowerCase()}${this._options.suffix}`);\r\n\r\n        (add ? this._controlElement.classList.add : this._controlElement.classList.remove).apply(this._controlElement.classList, errorsClasses);\r\n        (add ? this.wrapperElement.classList.add : this.wrapperElement.classList.remove).apply(this.wrapperElement.classList, errorsClasses);\r\n\r\n        this._errorMessageAttr.value = (add ? this._lastErrors.errorMessages : [])\r\n            .join(' ');\r\n\r\n        this._render(add);\r\n    }\r\n\r\n    /**\r\n     * Initialize renderer\r\n     */\r\n    protected _initialize()\r\n    {\r\n        this.wrapperElement = this._document.createElement('div');\r\n        this._hide();\r\n        this.wrapperElement.classList.add(this._options.wrapperDivClass);\r\n\r\n        this._errorMessageAttr = this._document.createAttribute('data-error-message');\r\n\r\n        this.wrapperElement.attributes.setNamedItem(this._errorMessageAttr);\r\n        this._controlElement.after(this.wrapperElement);\r\n    }\r\n\r\n    /**\r\n     * Renders error messages\r\n     * @param add - Indication whether add or remove errors\r\n     */\r\n    protected _render(add: boolean)\r\n    {\r\n        if(this._options.component)\r\n        {\r\n            this._renderComponent(add);\r\n        }\r\n        else if(this._options.template)\r\n        {\r\n            this._renderTemplate(add);\r\n        }\r\n        else\r\n        {\r\n            this._renderDivs(add);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Renders divs with errors\r\n     * @param add - Indication whether add or remove errors\r\n     */\r\n    protected _renderDivs(add: boolean = true)\r\n    {\r\n        if(!add)\r\n        {\r\n            let children = this.wrapperElement.children;\r\n    \r\n            //first clean old messages\r\n            for(let x = children.length - 1; x >= 0; x--)\r\n            {\r\n                children.item(x).remove();\r\n            }\r\n\r\n            return;\r\n        }\r\n\r\n        if(this._lastErrors?.errorMessages?.length)\r\n        {\r\n            this._lastErrors.errorMessages.forEach(message =>\r\n            {\r\n                let errorDiv = this._document.createElement('div');\r\n\r\n                errorDiv.innerText = message;\r\n\r\n                this.wrapperElement.append(errorDiv);\r\n            });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Renders component with errors\r\n     * @param add - Indication whether add or remove errors\r\n     */\r\n    protected _renderComponent(add: boolean = true)\r\n    {\r\n        if(add)\r\n        {\r\n            //render component\r\n            if(!this._component)\r\n            {\r\n                // 1. Create a component reference from the component \r\n                this._component = this._injector.get(ComponentFactoryResolver)\r\n                    .resolveComponentFactory(this._options.component)\r\n                    .create(this._injector);\r\n\r\n                // 2. Attach component to the appRef so that it's inside the ng component tree\r\n                this._injector.get(ApplicationRef).attachView(this._component.hostView);\r\n\r\n                // 3. Get DOM element from component\r\n                const domElem = (this._component.hostView as EmbeddedViewRef<any>)\r\n                    .rootNodes[0] as HTMLElement;\r\n\r\n                // 4. Append DOM element to the body\r\n                this.wrapperElement.append(domElem);\r\n            }\r\n\r\n            this._component.instance.show(this._lastErrors);\r\n        }\r\n        else if(this._component)\r\n        {\r\n            this._component.instance.show(null);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Renders template with errors\r\n     * @param add - Indication whether add or remove errors\r\n     */\r\n    protected _renderTemplate(_add: boolean = true)\r\n    {\r\n\r\n    }\r\n\r\n    /**\r\n     * Shows wrapper element\r\n     */\r\n    protected _show()\r\n    {\r\n        this.wrapperElement.style.display = 'block';\r\n    }\r\n\r\n    /**\r\n     * Hides wrapper element\r\n     */\r\n    protected _hide()\r\n    {\r\n        this.wrapperElement.style.display = 'none';\r\n    }\r\n}\r\n\r\nconst DEFAULT_OPTIONS: ValidationErrorRendererFactoryOptions =\r\n{\r\n    prefix: 'ng-',\r\n    suffix: '-error',\r\n    wrapperDivClass: 'validation-error-div',\r\n    rendererType: DefaultValidationErrorRenderer\r\n};"]}

package/date-fns/dist/es5/date-fns/index.js

@@ -0,0 +1,10 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: date-fns/index.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Generated bundle index. Do not edit.
+ */
+export { readEncodedFilterWithDates } from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQUlBLDJDQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/date-fns/dist/es5/date-fns/public_api.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: date-fns/public_api.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+export { readEncodedFilterWithDates } from './src/date-fns';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSwyQ0FBYyxnQkFBZ0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vc3JjL2RhdGUtZm5zJzsiXX0=

package/date-fns/dist/es5/date-fns/src/date-fns.js

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: date-fns/src/date-fns.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+export { readEncodedFilterWithDates } from './misc/utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1mbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0ZS1mbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSwyQ0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21pc2MvdXRpbHMnOyJdfQ==

package/date-fns/dist/es5/date-fns/src/misc/utils.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: date-fns/src/misc/utils.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { readEncodedFilter } from '@anglr/common/forms';
+import { isString } from '@jscrpt/common';
+import { parseISO } from 'date-fns';
+/**
+ * Reads filter value from encoded string, deserialize date properties into date
+ * @template TFilter
+ * @param {?} defaultValue Default value of filter, which is overriden by values from filterValue
+ * @param {?} filterValue Encoded string containing filter value
+ * @return {?}
+ */
+export function readEncodedFilterWithDates(defaultValue, filterValue) {
+    /** @type {?} */
+    var dateRegex = /^(\d+-){2}\d+(T(\d+:){2}\d+(\.\d+)?)?/g;
+    return readEncodedFilter(defaultValue, filterValue, (/**
+     * @param {?} _key
+     * @param {?} value
+     * @return {?}
+     */
+    function (_key, value) {
+        //it is date value
+        if (isString(value) && dateRegex.test(value)) {
+            /** @type {?} */
+            var val = parseISO(value);
+            //invalid date
+            if (isNaN(val.valueOf())) {
+                return null;
+            }
+            return val;
+        }
+        return value;
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,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