@bravobit/bb-foundation 0.26.2 → 0.27.0

package/{esm2020 → esm2022}/localize/lib/transforms/interpolate.transform.mjs

@@ -51,4 +51,4 @@ LocalizeInterpolateTransform = __decorate([
     __param(1, Inject(LOCALIZE_FUNCTION))
 ], LocalizeInterpolateTransform);
 export { LocalizeInterpolateTransform };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/localize/lib/transforms/reference.transform.mjs

@@ -22,4 +22,4 @@ LocalizeReferenceTransform = __decorate([
     __param(0, Optional())
 ], LocalizeReferenceTransform);
 export { LocalizeReferenceTransform };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/localize/lib/views/localize-string/localize-string.component.mjs

@@ -0,0 +1,89 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, Input, ViewEncapsulation } from '@angular/core';
+import { BbLocalizeTemplate } from '../localize-template.directive';
+import { startWith } from 'rxjs/operators';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@bravobit/bb-foundation/utils";
+class BbLocalizeString {
+    set value(value) {
+        this._value = value;
+        this.revalidate();
+    }
+    get value() {
+        return this._value;
+    }
+    constructor(_changeDetection) {
+        this._changeDetection = _changeDetection;
+        // Inputs.
+        this.substitutions = ['[', ']'];
+        // Data.
+        this.components = [];
+        // Subscriptions.
+        this._subscription = new Subscription();
+        // State.
+        this._value = null;
+    }
+    ngAfterViewInit() {
+        this.observeItemChanges();
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    observeItemChanges() {
+        const subscription = this.items.changes.pipe(startWith(0)).subscribe(() => this.revalidate());
+        this._subscription.add(subscription);
+    }
+    revalidate() {
+        const items = this.items?.toArray() ?? [];
+        if (items.length <= 0) {
+            return;
+        }
+        this.setComponents(items);
+    }
+    setComponents(items) {
+        const [start, end] = this.substitutions;
+        const templates = items.reduce((previous, current) => {
+            const template = current?.templateRef ?? null;
+            const name = current?.name ?? null;
+            if (!template || !name) {
+                return previous;
+            }
+            return { ...previous, [`${start}${name}${end}`]: template };
+        }, {});
+        this.components = this.getStringComponents(this._value)
+            .map(component => templates?.[component] ?? component ?? null)
+            .filter(item => !!item);
+        this._changeDetection.detectChanges();
+    }
+    getStringComponents(value) {
+        const [start, end] = this.getSubstitutions();
+        const regex = new RegExp(`(${start}[a-zA-Z]+${end})`, 'g');
+        return value.split(regex);
+    }
+    getSubstitutions() {
+        const [start, end] = this.substitutions;
+        const escape = /[.*+?^${}()|[\]\\]/g;
+        return [
+            start.replace(escape, '\\$&'),
+            end.replace(escape, '\\$&')
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbLocalizeString, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: BbLocalizeString, selector: "bb-localize-string, [bb-localize-string]", inputs: { substitutions: "substitutions", value: "value" }, host: { classAttribute: "bb-localize-string" }, queries: [{ propertyName: "items", predicate: BbLocalizeTemplate }], ngImport: i0, template: "<ng-container *ngFor=\"let component of components\">\n    <ng-template [bbTemplate]=\"component\">{{ component }}</ng-template>\n</ng-container>\n", styles: [".bb-localize-string{display:inline}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.BbTemplate, selector: "[bbTemplate]", inputs: ["bbTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { BbLocalizeString };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbLocalizeString, decorators: [{
+            type: Component,
+            args: [{ selector: 'bb-localize-string, [bb-localize-string]', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, preserveWhitespaces: false, host: {
+                        'class': 'bb-localize-string'
+                    }, template: "<ng-container *ngFor=\"let component of components\">\n    <ng-template [bbTemplate]=\"component\">{{ component }}</ng-template>\n</ng-container>\n", styles: [".bb-localize-string{display:inline}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { items: [{
+                type: ContentChildren,
+                args: [BbLocalizeTemplate]
+            }], substitutions: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"localize-string.component.js","sourceRoot":"","sources":["../../../../../../../projects/bb-foundation/localize/src/lib/views/localize-string/localize-string.component.ts","../../../../../../../projects/bb-foundation/localize/src/lib/views/localize-string/localize-string.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChildren,\n    Input,\n    OnDestroy,\n    QueryList,\n    TemplateRef,\n    ViewEncapsulation\n} from '@angular/core';\nimport {BbLocalizeTemplate} from '../localize-template.directive';\nimport {startWith} from 'rxjs/operators';\nimport {Subscription} from 'rxjs';\n\n@Component({\n    selector: 'bb-localize-string, [bb-localize-string]',\n    templateUrl: './localize-string.component.html',\n    styleUrls: ['./localize-string.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n    preserveWhitespaces: false,\n    host: {\n        'class': 'bb-localize-string'\n    }\n})\nexport class BbLocalizeString implements AfterViewInit, OnDestroy {\n\n    // Content children.\n    @ContentChildren(BbLocalizeTemplate) items?: QueryList<BbLocalizeTemplate>;\n\n    // Inputs.\n    @Input() substitutions: [string, string] = ['[', ']'];\n\n    // Data.\n    components: (string | TemplateRef<any>)[] = [];\n\n    // Subscriptions.\n    private _subscription = new Subscription();\n\n    // State.\n    private _value: string | null = null;\n\n    @Input()\n    set value(value: string | null) {\n        this._value = value;\n        this.revalidate();\n    }\n\n    get value() {\n        return this._value;\n    }\n\n    constructor(private _changeDetection: ChangeDetectorRef) {\n    }\n\n    ngAfterViewInit() {\n        this.observeItemChanges();\n    }\n\n    ngOnDestroy() {\n        this._subscription?.unsubscribe();\n    }\n\n    private observeItemChanges() {\n        const subscription = this.items.changes.pipe(\n            startWith(0)\n        ).subscribe(() => this.revalidate());\n\n        this._subscription.add(subscription);\n    }\n\n    private revalidate() {\n        const items = this.items?.toArray() ?? [];\n        if (items.length <= 0) {\n            return;\n        }\n\n        this.setComponents(items);\n    }\n\n    private setComponents(items: BbLocalizeTemplate[]) {\n        const [start, end] = this.substitutions;\n\n        const templates = items.reduce((previous, current) => {\n            const template = current?.templateRef ?? null;\n            const name = current?.name ?? null;\n            if (!template || !name) {\n                return previous;\n            }\n\n            return {...previous, [`${start}${name}${end}`]: template};\n        }, {});\n\n        this.components = this.getStringComponents(this._value)\n            .map(component => templates?.[component] ?? component ?? null)\n            .filter(item => !!item);\n\n        this._changeDetection.detectChanges();\n    }\n\n    private getStringComponents(value: string) {\n        const [start, end] = this.getSubstitutions();\n        const regex = new RegExp(`(${start}[a-zA-Z]+${end})`, 'g');\n        return value.split(regex);\n    }\n\n    private getSubstitutions() {\n        const [start, end] = this.substitutions;\n        const escape = /[.*+?^${}()|[\\]\\\\]/g;\n\n        return [\n            start.replace(escape, '\\\\$&'),\n            end.replace(escape, '\\\\$&')\n        ];\n    }\n\n}\n","<ng-container *ngFor=\"let component of components\">\n    <ng-template [bbTemplate]=\"component\">{{ component }}</ng-template>\n</ng-container>\n"]}

package/esm2022/localize/lib/views/localize-template.directive.mjs

@@ -0,0 +1,22 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+class BbLocalizeTemplate {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+        // Inputs.
+        this.name = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbLocalizeTemplate, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BbLocalizeTemplate, selector: "[bbLocalizeTemplate]", inputs: { name: ["bbLocalizeTemplate", "name"] }, ngImport: i0 }); }
+}
+export { BbLocalizeTemplate };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbLocalizeTemplate, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bbLocalizeTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { name: [{
+                type: Input,
+                args: ['bbLocalizeTemplate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWxpemUtdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYmItZm91bmRhdGlvbi9sb2NhbGl6ZS9zcmMvbGliL3ZpZXdzL2xvY2FsaXplLXRlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLEtBQUssRUFBYyxNQUFNLGVBQWUsQ0FBQzs7QUFFNUQsTUFHYSxrQkFBa0I7SUFLM0IsWUFBbUIsV0FBNkI7UUFBN0IsZ0JBQVcsR0FBWCxXQUFXLENBQWtCO1FBSGhELFVBQVU7UUFDbUIsU0FBSSxHQUFrQixJQUFJLENBQUM7SUFHeEQsQ0FBQzs4R0FOUSxrQkFBa0I7a0dBQWxCLGtCQUFrQjs7U0FBbEIsa0JBQWtCOzJGQUFsQixrQkFBa0I7a0JBSDlCLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHNCQUFzQjtpQkFDbkM7a0dBSWdDLElBQUk7c0JBQWhDLEtBQUs7dUJBQUMsb0JBQW9CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtEaXJlY3RpdmUsIElucHV0LCBUZW1wbGF0ZVJlZn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW2JiTG9jYWxpemVUZW1wbGF0ZV0nXG59KVxuZXhwb3J0IGNsYXNzIEJiTG9jYWxpemVUZW1wbGF0ZSB7XG5cbiAgICAvLyBJbnB1dHMuXG4gICAgQElucHV0KCdiYkxvY2FsaXplVGVtcGxhdGUnKSBuYW1lOiBzdHJpbmcgfCBudWxsID0gbnVsbDtcblxuICAgIGNvbnN0cnVjdG9yKHB1YmxpYyB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8YW55Pikge1xuICAgIH1cblxufVxuIl19

package/esm2022/masking/lib/directives/currency-mask.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, Input, Self } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../masking.service";
+import * as i2 from "./input-mask.directive";
+class BbCurrencyMask {
+    constructor(_masking, _inputMask) {
+        this._masking = _masking;
+        this._inputMask = _inputMask;
+        // Inputs.
+        this.currencyCode = null;
+        this.options = null;
+    }
+    ngOnChanges(changes) {
+        const currencyCode = changes?.['currencyCode']?.currentValue ?? this.currencyCode ?? 'USD';
+        const options = changes?.['options']?.currentValue ?? this.options ?? {};
+        this._inputMask.mask = this._masking.currency(currencyCode, options);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbCurrencyMask, deps: [{ token: i1.Masking }, { token: i2.BbInputMask, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BbCurrencyMask, selector: "input[bbCurrencyMask]", inputs: { currencyCode: ["bbCurrencyMask", "currencyCode"], options: ["bbCurrencyMaskOptions", "options"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+export { BbCurrencyMask };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbCurrencyMask, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[bbCurrencyMask]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Masking }, { type: i2.BbInputMask, decorators: [{
+                    type: Self
+                }] }]; }, propDecorators: { currencyCode: [{
+                type: Input,
+                args: ['bbCurrencyMask']
+            }], options: [{
+                type: Input,
+                args: ['bbCurrencyMaskOptions']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVuY3ktbWFzay5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYi1mb3VuZGF0aW9uL21hc2tpbmcvc3JjL2xpYi9kaXJlY3RpdmVzL2N1cnJlbmN5LW1hc2suZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsS0FBSyxFQUFhLElBQUksRUFBZ0IsTUFBTSxlQUFlLENBQUM7Ozs7QUFLL0UsTUFHYSxjQUFjO0lBTXZCLFlBQW9CLFFBQWlCLEVBQ1QsVUFBdUI7UUFEL0IsYUFBUSxHQUFSLFFBQVEsQ0FBUztRQUNULGVBQVUsR0FBVixVQUFVLENBQWE7UUFMbkQsVUFBVTtRQUNlLGlCQUFZLEdBQWtCLElBQUksQ0FBQztRQUM1QixZQUFPLEdBQXdDLElBQUksQ0FBQztJQUlwRixDQUFDO0lBRUQsV0FBVyxDQUFDLE9BQXNCO1FBQzlCLE1BQU0sWUFBWSxHQUFHLE9BQU8sRUFBRSxDQUFDLGNBQWMsQ0FBQyxFQUFFLFlBQVksSUFBSSxJQUFJLENBQUMsWUFBWSxJQUFJLEtBQUssQ0FBQztRQUMzRixNQUFNLE9BQU8sR0FBRyxPQUFPLEVBQUUsQ0FBQyxTQUFTLENBQUMsRUFBRSxZQUFZLElBQUksSUFBSSxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUM7UUFFekUsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsWUFBWSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3pFLENBQUM7OEdBZlEsY0FBYztrR0FBZCxjQUFjOztTQUFkLGNBQWM7MkZBQWQsY0FBYztrQkFIMUIsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsdUJBQXVCO2lCQUNwQzs7MEJBUWdCLElBQUk7NENBSlEsWUFBWTtzQkFBcEMsS0FBSzt1QkFBQyxnQkFBZ0I7Z0JBQ1MsT0FBTztzQkFBdEMsS0FBSzt1QkFBQyx1QkFBdUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSW5wdXQsIE9uQ2hhbmdlcywgU2VsZiwgU2ltcGxlQ2hhbmdlc30gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0N1cnJlbmN5TWFza09wdGlvbnN9IGZyb20gJy4uL2lucHV0LW1hc2suaW50ZXJmYWNlJztcbmltcG9ydCB7QmJJbnB1dE1hc2t9IGZyb20gJy4vaW5wdXQtbWFzay5kaXJlY3RpdmUnO1xuaW1wb3J0IHtNYXNraW5nfSBmcm9tICcuLi9tYXNraW5nLnNlcnZpY2UnO1xuXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ2lucHV0W2JiQ3VycmVuY3lNYXNrXSdcbn0pXG5leHBvcnQgY2xhc3MgQmJDdXJyZW5jeU1hc2sgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xuXG4gICAgLy8gSW5wdXRzLlxuICAgIEBJbnB1dCgnYmJDdXJyZW5jeU1hc2snKSBjdXJyZW5jeUNvZGU6IHN0cmluZyB8IG51bGwgPSBudWxsO1xuICAgIEBJbnB1dCgnYmJDdXJyZW5jeU1hc2tPcHRpb25zJykgb3B0aW9uczogUGFydGlhbDxDdXJyZW5jeU1hc2tPcHRpb25zPiB8IG51bGwgPSBudWxsO1xuXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBfbWFza2luZzogTWFza2luZyxcbiAgICAgICAgICAgICAgICBAU2VsZigpIHByaXZhdGUgX2lucHV0TWFzazogQmJJbnB1dE1hc2spIHtcbiAgICB9XG5cbiAgICBuZ09uQ2hhbmdlcyhjaGFuZ2VzOiBTaW1wbGVDaGFuZ2VzKSB7XG4gICAgICAgIGNvbnN0IGN1cnJlbmN5Q29kZSA9IGNoYW5nZXM/LlsnY3VycmVuY3lDb2RlJ10/LmN1cnJlbnRWYWx1ZSA/PyB0aGlzLmN1cnJlbmN5Q29kZSA/PyAnVVNEJztcbiAgICAgICAgY29uc3Qgb3B0aW9ucyA9IGNoYW5nZXM/Llsnb3B0aW9ucyddPy5jdXJyZW50VmFsdWUgPz8gdGhpcy5vcHRpb25zID8/IHt9O1xuXG4gICAgICAgIHRoaXMuX2lucHV0TWFzay5tYXNrID0gdGhpcy5fbWFza2luZy5jdXJyZW5jeShjdXJyZW5jeUNvZGUsIG9wdGlvbnMpO1xuICAgIH1cblxuICAgIC8vIFJlcXVpcmVkIHNvIHRoYXQgdGhlIHRlbXBsYXRlIHR5cGUgY2hlY2tlciBjYW4gaW5mZXIgdGhlIHR5cGUgb2YgdGhlIGNvZXJjZWQgaW5wdXRzLlxuICAgIHN0YXRpYyBuZ0FjY2VwdElucHV0VHlwZV9iYkN1cnJlbmN5TWFzazogc3RyaW5nIHwgbnVsbCB8IHVuZGVmaW5lZDtcbiAgICBzdGF0aWMgbmdBY2NlcHRJbnB1dFR5cGVfYmJDdXJyZW5jeU1hc2tPcHRpb25zOiBQYXJ0aWFsPEN1cnJlbmN5TWFza09wdGlvbnM+IHwgbnVsbCB8IHVuZGVmaW5lZDtcblxufVxuIl19

package/esm2022/masking/lib/directives/date-mask.directive.mjs

@@ -0,0 +1,36 @@
+import { Directive, Input, Self } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../masking.service";
+import * as i2 from "./input-mask.directive";
+class BbDateMask {
+    constructor(_masking, _inputMask) {
+        this._masking = _masking;
+        this._inputMask = _inputMask;
+        // Inputs.
+        this.format = null;
+        this.separator = null;
+    }
+    ngOnChanges(changes) {
+        const format = changes?.['format']?.currentValue ?? this.format ?? null;
+        const separator = changes?.['separator']?.currentValue ?? this.separator ?? '-';
+        this._inputMask.mask = this._masking.date(format, separator);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbDateMask, deps: [{ token: i1.Masking }, { token: i2.BbInputMask, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BbDateMask, selector: "input[bbDateMask]", inputs: { format: ["bbDateMask", "format"], separator: ["bbDateMaskSeparator", "separator"] }, usesOnChanges: true, ngImport: i0 }); }
+}
+export { BbDateMask };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbDateMask, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[bbDateMask]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Masking }, { type: i2.BbInputMask, decorators: [{
+                    type: Self
+                }] }]; }, propDecorators: { format: [{
+                type: Input,
+                args: ['bbDateMask']
+            }], separator: [{
+                type: Input,
+                args: ['bbDateMaskSeparator']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/masking/lib/directives/input-mask.directive.mjs

@@ -0,0 +1,119 @@
+import { Directive, HostListener, Input, Optional, Self } from '@angular/core';
+import { fromEvent, merge } from 'rxjs';
+import _Inputmask from 'inputmask';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+import * as i2 from "@angular/forms";
+const InputmaskConstructor = _Inputmask.default || _Inputmask;
+class BbInputMask {
+    set mask(mask) {
+        if (!mask || typeof mask === 'string') {
+            return;
+        }
+        this._inputMaskOptions = mask;
+        this.updateMask();
+    }
+    constructor(_ngZone, _platform, _renderer, _elementRef, _control) {
+        this._ngZone = _ngZone;
+        this._platform = _platform;
+        this._renderer = _renderer;
+        this._elementRef = _elementRef;
+        this._control = _control;
+        // State.
+        this.inputMaskPlugin = null;
+        this.nativeInputElement = null;
+        this.eventsSubscription = null;
+        this._inputMaskOptions = null;
+        this._onChange = () => ({});
+        this.onInput = (_) => ({});
+        this.onTouched = () => ({});
+        this.validate = (control) => !control.value || !this.inputMaskPlugin || this.inputMaskPlugin?.isValid()
+            ? null
+            : { inputMask: true };
+        this.nativeInputElement = this._elementRef.nativeElement;
+        if (this._control != null) {
+            this._control.valueAccessor = this;
+        }
+    }
+    ngOnInit() {
+        const control = this._control?.control;
+        if (!control) {
+            return;
+        }
+        control?.setValidators(control.validator ? [control.validator, this.validate] : [this.validate]);
+        control?.updateValueAndValidity();
+    }
+    ngOnDestroy() {
+        this.destroyMask();
+    }
+    writeValue(value) {
+        if (!this.nativeInputElement) {
+            return;
+        }
+        this._renderer.setProperty(this.nativeInputElement, 'value', value ?? '');
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+        const parser = this._inputMaskOptions?.parser;
+        this.onInput = value => this._onChange(parser ? parser(value) : value);
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        if (!this.nativeInputElement) {
+            return;
+        }
+        this._renderer.setProperty(this.nativeInputElement, 'disabled', isDisabled);
+    }
+    updateMask() {
+        this.destroyMask();
+        this.createMask();
+        this.registerOnChange(this._onChange);
+    }
+    createMask() {
+        if (!this._platform.isBrowser || !this.nativeInputElement || this._inputMaskOptions === null || Object.keys(this._inputMaskOptions).length === 0) {
+            return;
+        }
+        const { parser, ...options } = this._inputMaskOptions;
+        this.inputMaskPlugin = this._ngZone.runOutsideAngular(() => new InputmaskConstructor(options).mask(this.nativeInputElement));
+        const setValue$ = fromEvent(this.nativeInputElement, 'setvalue');
+        const cleared$ = fromEvent(this.nativeInputElement, 'cleared');
+        this.eventsSubscription = merge(setValue$, cleared$)
+            .subscribe(event => this.onInput(event?.target?.['value']));
+        const control = this._control?.control;
+        if (!control) {
+            return;
+        }
+        setTimeout(() => control?.updateValueAndValidity());
+    }
+    destroyMask() {
+        this.eventsSubscription?.unsubscribe();
+        this.eventsSubscription = null;
+        this.inputMaskPlugin?.remove();
+        this.inputMaskPlugin = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbInputMask, deps: [{ token: i0.NgZone }, { token: i1.Platform }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BbInputMask, selector: "input[bbInputMask],input[bbCurrencyMask],input[bbDateMask]", inputs: { mask: ["bbInputMask", "mask"] }, host: { listeners: { "input": "onInput($event.target.value)", "blur": "onTouched($event.target.value)" } }, ngImport: i0 }); }
+}
+export { BbInputMask };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbInputMask, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[bbInputMask],input[bbCurrencyMask],input[bbDateMask]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i1.Platform }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i2.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }]; }, propDecorators: { mask: [{
+                type: Input,
+                args: ['bbInputMask']
+            }], onInput: [{
+                type: HostListener,
+                args: ['input', ['$event.target.value']]
+            }], onTouched: [{
+                type: HostListener,
+                args: ['blur', ['$event.target.value']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-mask.directive.js","sourceRoot":"","sources":["../../../../../../projects/bb-foundation/masking/src/lib/directives/input-mask.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, HostListener, Input, NgZone, OnDestroy, OnInit, Optional, Renderer2, Self} from '@angular/core';\nimport {AbstractControl, ControlValueAccessor, NgControl, Validator} from '@angular/forms';\nimport {InputMaskOptions} from '../input-mask.interface';\nimport {fromEvent, merge, Subscription} from 'rxjs';\nimport {Platform} from '@angular/cdk/platform';\nimport type Inputmask from 'inputmask';\nimport _Inputmask from 'inputmask';\n\nconst InputmaskConstructor = (_Inputmask as unknown as { default?: Inputmask.Static }).default || _Inputmask;\n\n@Directive({\n    selector: 'input[bbInputMask],input[bbCurrencyMask],input[bbDateMask]'\n})\nexport class BbInputMask<T = any> implements OnInit, OnDestroy, ControlValueAccessor, Validator {\n\n    @Input('bbInputMask')\n    set mask(mask: InputMaskOptions<T> | string | null | undefined) {\n        if (!mask || typeof mask === 'string') {\n            return;\n        }\n\n        this._inputMaskOptions = mask;\n        this.updateMask();\n    }\n\n    // State.\n    inputMaskPlugin: Inputmask.Instance | null = null;\n    nativeInputElement: HTMLInputElement | null = null;\n    eventsSubscription: Subscription | null = null;\n\n    private _inputMaskOptions: InputMaskOptions<T> | null = null;\n    private _onChange: (value: T | null) => void = () => ({});\n\n    constructor(private _ngZone: NgZone,\n                private _platform: Platform,\n                private _renderer: Renderer2,\n                private _elementRef: ElementRef<HTMLInputElement>,\n                @Optional() @Self() private _control?: NgControl) {\n        this.nativeInputElement = this._elementRef.nativeElement;\n        if (this._control != null) {\n            this._control.valueAccessor = this;\n        }\n    }\n\n    @HostListener('input', ['$event.target.value'])\n    onInput: (value: any) => void = (_: any) => ({});\n\n    @HostListener('blur', ['$event.target.value'])\n    onTouched: () => void = () => ({});\n\n    ngOnInit() {\n        const control = this._control?.control;\n        if (!control) {\n            return;\n        }\n\n        control?.setValidators(control.validator ? [control.validator, this.validate] : [this.validate]);\n        control?.updateValueAndValidity();\n    }\n\n    ngOnDestroy() {\n        this.destroyMask();\n    }\n\n    writeValue(value: string) {\n        if (!this.nativeInputElement) {\n            return;\n        }\n        this._renderer.setProperty(this.nativeInputElement, 'value', value ?? '');\n    }\n\n    registerOnChange(fn: (value: T | null) => void) {\n        this._onChange = fn;\n        const parser = this._inputMaskOptions?.parser;\n        this.onInput = value => this._onChange(parser ? parser(value) : value);\n    }\n\n    registerOnTouched(fn: () => void) {\n        this.onTouched = fn;\n    }\n\n    setDisabledState(isDisabled: boolean) {\n        if (!this.nativeInputElement) {\n            return;\n        }\n        this._renderer.setProperty(this.nativeInputElement, 'disabled', isDisabled);\n    }\n\n    validate = (control: AbstractControl) => !control.value || !this.inputMaskPlugin || this.inputMaskPlugin?.isValid()\n        ? null\n        : {inputMask: true};\n\n    private updateMask() {\n        this.destroyMask();\n        this.createMask();\n        this.registerOnChange(this._onChange);\n    }\n\n    private createMask() {\n        if (!this._platform.isBrowser || !this.nativeInputElement || this._inputMaskOptions === null || Object.keys(this._inputMaskOptions).length === 0) {\n            return;\n        }\n\n        const {parser, ...options} = this._inputMaskOptions;\n        this.inputMaskPlugin = this._ngZone.runOutsideAngular(() => new InputmaskConstructor(options).mask(this.nativeInputElement));\n\n        const setValue$ = fromEvent(this.nativeInputElement, 'setvalue');\n        const cleared$ = fromEvent(this.nativeInputElement, 'cleared');\n\n        this.eventsSubscription = merge(setValue$, cleared$)\n            .subscribe(event => this.onInput(event?.target?.['value']));\n\n        const control = this._control?.control;\n        if (!control) {\n            return;\n        }\n        setTimeout(() => control?.updateValueAndValidity());\n    }\n\n    private destroyMask() {\n        this.eventsSubscription?.unsubscribe();\n        this.eventsSubscription = null;\n        this.inputMaskPlugin?.remove();\n        this.inputMaskPlugin = null;\n    }\n\n    // Required so that the template type checker can infer the type of the coerced inputs.\n    static ngAcceptInputType_bbInputMask: InputMaskOptions<any> | string | null | undefined;\n\n}\n"]}

package/esm2022/masking/lib/masking.module.mjs

@@ -0,0 +1,31 @@
+import { BbCurrencyMask } from './directives/currency-mask.directive';
+import { BbInputMask } from './directives/input-mask.directive';
+import { BbDateMask } from './directives/date-mask.directive';
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+class MaskingModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MaskingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: MaskingModule, declarations: [BbInputMask,
+            BbCurrencyMask,
+            BbDateMask], exports: [BbInputMask,
+            BbCurrencyMask,
+            BbDateMask] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MaskingModule }); }
+}
+export { MaskingModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: MaskingModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        BbInputMask,
+                        BbCurrencyMask,
+                        BbDateMask
+                    ],
+                    exports: [
+                        BbInputMask,
+                        BbCurrencyMask,
+                        BbDateMask
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFza2luZy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYi1mb3VuZGF0aW9uL21hc2tpbmcvc3JjL2xpYi9tYXNraW5nLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sc0NBQXNDLENBQUM7QUFDcEUsT0FBTyxFQUFDLFdBQVcsRUFBQyxNQUFNLG1DQUFtQyxDQUFDO0FBQzlELE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxrQ0FBa0MsQ0FBQztBQUM1RCxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQUV2QyxNQVlhLGFBQWE7OEdBQWIsYUFBYTsrR0FBYixhQUFhLGlCQVZsQixXQUFXO1lBQ1gsY0FBYztZQUNkLFVBQVUsYUFHVixXQUFXO1lBQ1gsY0FBYztZQUNkLFVBQVU7K0dBR0wsYUFBYTs7U0FBYixhQUFhOzJGQUFiLGFBQWE7a0JBWnpCLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFO3dCQUNWLFdBQVc7d0JBQ1gsY0FBYzt3QkFDZCxVQUFVO3FCQUNiO29CQUNELE9BQU8sRUFBRTt3QkFDTCxXQUFXO3dCQUNYLGNBQWM7d0JBQ2QsVUFBVTtxQkFDYjtpQkFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7QmJDdXJyZW5jeU1hc2t9IGZyb20gJy4vZGlyZWN0aXZlcy9jdXJyZW5jeS1tYXNrLmRpcmVjdGl2ZSc7XG5pbXBvcnQge0JiSW5wdXRNYXNrfSBmcm9tICcuL2RpcmVjdGl2ZXMvaW5wdXQtbWFzay5kaXJlY3RpdmUnO1xuaW1wb3J0IHtCYkRhdGVNYXNrfSBmcm9tICcuL2RpcmVjdGl2ZXMvZGF0ZS1tYXNrLmRpcmVjdGl2ZSc7XG5pbXBvcnQge05nTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtcbiAgICAgICAgQmJJbnB1dE1hc2ssXG4gICAgICAgIEJiQ3VycmVuY3lNYXNrLFxuICAgICAgICBCYkRhdGVNYXNrXG4gICAgXSxcbiAgICBleHBvcnRzOiBbXG4gICAgICAgIEJiSW5wdXRNYXNrLFxuICAgICAgICBCYkN1cnJlbmN5TWFzayxcbiAgICAgICAgQmJEYXRlTWFza1xuICAgIF1cbn0pXG5leHBvcnQgY2xhc3MgTWFza2luZ01vZHVsZSB7XG59XG4iXX0=

package/esm2022/masking/lib/masking.service.mjs

@@ -0,0 +1,104 @@
+import { formatDate, getCurrencySymbol, getLocaleNumberSymbol, getNumberOfCurrencyDigits, NumberSymbol } from '@angular/common';
+import { createMask } from './input-mask.interface';
+import { Injectable, Optional } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@bravobit/bb-foundation/localize";
+class Masking {
+    constructor(_localize) {
+        this._localize = _localize;
+    }
+    date(format, separator = '-') {
+        const dateParts = this.getDateParts(format);
+        const inputFormat = dateParts.join(separator);
+        const outputFormat = 'yyyy-MM-dd';
+        const escape = /[.*+?^${}()\/|[\]\\]/g;
+        const escapedSeparator = separator.replace(escape, '\\$&');
+        const inputFormatRegexString = dateParts
+            .map(item => `(?<${item}>[0-9]{${item?.length}})`)
+            .join(escapedSeparator);
+        const inputFormatRegex = new RegExp(`^${inputFormatRegexString}$`);
+        return createMask({
+            alias: 'datetime',
+            inputFormat: inputFormat.toLowerCase(),
+            outputFormat: outputFormat.toLowerCase(),
+            nullable: false,
+            inputmode: 'numeric',
+            onBeforeMask: (initialValue) => {
+                return initialValue ? formatDate(initialValue, inputFormat, 'en-US') : null;
+            },
+            onBeforePaste: (value) => {
+                return value;
+            },
+            parser: (value) => {
+                if (!value || typeof value !== 'string' || !inputFormatRegex.test(value)) {
+                    return null;
+                }
+                const matches = value.match(inputFormatRegex);
+                const year = +matches?.groups?.['yyyy'];
+                const month = +matches?.groups?.['MM'] - 1;
+                const day = +matches?.groups?.['dd'];
+                const date = new Date(year, month, day);
+                return date instanceof Date && !isNaN(date)
+                    ? formatDate(date, outputFormat, 'en-US')
+                    : null;
+            }
+        });
+    }
+    currency(code, options) {
+        const locale = this._localize?.current?.locale ?? 'en';
+        const symbol = options?.symbol ?? getCurrencySymbol(code, options?.symbolFormat ?? 'narrow', locale);
+        const decimal = options?.decimalCharacter ?? getLocaleNumberSymbol(locale, NumberSymbol.CurrencyDecimal);
+        const group = options?.groupCharacter ?? getLocaleNumberSymbol(locale, NumberSymbol.CurrencyGroup);
+        const digits = options?.digits ?? getNumberOfCurrencyDigits(code);
+        const spacer = options?.spacer ?? ' ';
+        return createMask({
+            alias: 'numeric',
+            digits: digits,
+            allowMinus: options?.allowMinus ?? false,
+            min: options?.min ?? 0,
+            max: options?.max ?? Number.MAX_SAFE_INTEGER,
+            prefix: `${symbol}${spacer}`,
+            radixPoint: decimal ?? '.',
+            groupSeparator: group ?? ',',
+            digitsOptional: options?.digitsOptional ?? false,
+            nullable: options?.nullable ?? true,
+            autoUnmask: true,
+            unmaskAsNumber: true,
+            rightAlign: false,
+            showMaskOnHover: false,
+            showMaskOnFocus: false,
+            inputmode: digits > 0 ? 'decimal' : 'numeric',
+            parser: (value) => {
+                if (value === '') {
+                    return null;
+                }
+                return value;
+            }
+        });
+    }
+    getDateParts(format) {
+        switch (format) {
+            case 'day-month-year':
+                return ['dd', 'MM', 'yyyy'];
+            case 'month-day-year':
+                return ['MM', 'dd', 'yyyy'];
+            case 'year-day-month':
+                return ['yyyy', 'dd', 'MM'];
+            case 'year-month-day':
+            default:
+                return ['yyyy', 'MM', 'dd'];
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Masking, deps: [{ token: i1.Localize, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Masking, providedIn: 'root' }); }
+}
+export { Masking };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Masking, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Localize, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"masking.service.js","sourceRoot":"","sources":["../../../../../projects/bb-foundation/masking/src/lib/masking.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC9H,OAAO,EAAC,UAAU,EAAsC,MAAM,wBAAwB,CAAC;AAEvF,OAAO,EAAC,UAAU,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;;;AAEnD,MAGa,OAAO;IAEhB,YAAgC,SAAoB;QAApB,cAAS,GAAT,SAAS,CAAW;IACpD,CAAC;IAED,IAAI,CAAC,MAAsB,EAAE,YAAoB,GAAG;QAChD,MAAM,SAAS,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC5C,MAAM,WAAW,GAAG,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9C,MAAM,YAAY,GAAG,YAAY,CAAC;QAElC,MAAM,MAAM,GAAG,uBAAuB,CAAC;QACvC,MAAM,gBAAgB,GAAG,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAE3D,MAAM,sBAAsB,GAAG,SAAS;aACnC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,IAAI,UAAU,IAAI,EAAE,MAAM,IAAI,CAAC;aACjD,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAC5B,MAAM,gBAAgB,GAAG,IAAI,MAAM,CAAC,IAAI,sBAAsB,GAAG,CAAC,CAAC;QAEnE,OAAO,UAAU,CAAC;YACd,KAAK,EAAE,UAAU;YACjB,WAAW,EAAE,WAAW,CAAC,WAAW,EAAE;YACtC,YAAY,EAAE,YAAY,CAAC,WAAW,EAAE;YACxC,QAAQ,EAAE,KAAK;YACf,SAAS,EAAE,SAAS;YACpB,YAAY,EAAE,CAAC,YAAoB,EAAE,EAAE;gBACnC,OAAO,YAAY,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YAChF,CAAC;YACD,aAAa,EAAE,CAAC,KAAa,EAAE,EAAE;gBAC7B,OAAO,KAAK,CAAC;YACjB,CAAC;YACD,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;gBACtB,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;oBACtE,OAAO,IAAI,CAAC;iBACf;gBACD,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;gBAC9C,MAAM,IAAI,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;gBACxC,MAAM,KAAK,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC3C,MAAM,GAAG,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC;gBACrC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;gBAExC,OAAO,IAAI,YAAY,IAAI,IAAI,CAAC,KAAK,CAAM,IAAI,CAAC;oBAC5C,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC;oBACzC,CAAC,CAAC,IAAI,CAAC;YACf,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;IAED,QAAQ,CAAC,IAAY,EAAE,OAAsC;QACzD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,IAAI,IAAI,CAAC;QACvD,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,YAAY,IAAI,QAAQ,EAAE,MAAM,CAAC,CAAC;QAErG,MAAM,OAAO,GAAG,OAAO,EAAE,gBAAgB,IAAI,qBAAqB,CAAC,MAAM,EAAE,YAAY,CAAC,eAAe,CAAC,CAAC;QACzG,MAAM,KAAK,GAAG,OAAO,EAAE,cAAc,IAAI,qBAAqB,CAAC,MAAM,EAAE,YAAY,CAAC,aAAa,CAAC,CAAC;QACnG,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAC;QAClE,MAAM,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,GAAG,CAAC;QAEtC,OAAO,UAAU,CAAC;YACd,KAAK,EAAE,SAAS;YAChB,MAAM,EAAE,MAAM;YACd,UAAU,EAAE,OAAO,EAAE,UAAU,IAAI,KAAK;YACxC,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;YACtB,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,MAAM,CAAC,gBAAgB;YAC5C,MAAM,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE;YAC5B,UAAU,EAAE,OAAO,IAAI,GAAG;YAC1B,cAAc,EAAE,KAAK,IAAI,GAAG;YAC5B,cAAc,EAAE,OAAO,EAAE,cAAc,IAAI,KAAK;YAChD,QAAQ,EAAE,OAAO,EAAE,QAAQ,IAAI,IAAI;YACnC,UAAU,EAAE,IAAI;YAChB,cAAc,EAAE,IAAI;YACpB,UAAU,EAAE,KAAK;YACjB,eAAe,EAAE,KAAK;YACtB,eAAe,EAAE,KAAK;YACtB,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;YAC7C,MAAM,EAAE,CAAC,KAAsB,EAAE,EAAE;gBAC/B,IAAI,KAAK,KAAK,EAAE,EAAE;oBACd,OAAO,IAAI,CAAC;iBACf;gBACD,OAAO,KAAK,CAAC;YACjB,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;IAEO,YAAY,CAAC,MAAsB;QACvC,QAAQ,MAAM,EAAE;YACZ,KAAK,gBAAgB;gBACjB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;YAChC,KAAK,gBAAgB;gBACjB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;YAChC,KAAK,gBAAgB;gBACjB,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;YAChC,KAAK,gBAAgB,CAAC;YACtB;gBACI,OAAO,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;SACnC;IACL,CAAC;8GA9FQ,OAAO;kHAAP,OAAO,cAFJ,MAAM;;SAET,OAAO;2FAAP,OAAO;kBAHnB,UAAU;mBAAC;oBACR,UAAU,EAAE,MAAM;iBACrB;;0BAGgB,QAAQ","sourcesContent":["import {formatDate, getCurrencySymbol, getLocaleNumberSymbol, getNumberOfCurrencyDigits, NumberSymbol} from '@angular/common';\nimport {createMask, CurrencyMaskOptions, DateMaskFormat} from './input-mask.interface';\nimport {Localize} from '@bravobit/bb-foundation/localize';\nimport {Injectable, Optional} from '@angular/core';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class Masking {\n\n    constructor(@Optional() private _localize?: Localize) {\n    }\n\n    date(format: DateMaskFormat, separator: string = '-') {\n        const dateParts = this.getDateParts(format);\n        const inputFormat = dateParts.join(separator);\n        const outputFormat = 'yyyy-MM-dd';\n\n        const escape = /[.*+?^${}()\\/|[\\]\\\\]/g;\n        const escapedSeparator = separator.replace(escape, '\\\\$&');\n\n        const inputFormatRegexString = dateParts\n            .map(item => `(?<${item}>[0-9]{${item?.length}})`)\n            .join(escapedSeparator);\n        const inputFormatRegex = new RegExp(`^${inputFormatRegexString}$`);\n\n        return createMask({\n            alias: 'datetime',\n            inputFormat: inputFormat.toLowerCase(),\n            outputFormat: outputFormat.toLowerCase(),\n            nullable: false,\n            inputmode: 'numeric',\n            onBeforeMask: (initialValue: string) => {\n                return initialValue ? formatDate(initialValue, inputFormat, 'en-US') : null;\n            },\n            onBeforePaste: (value: string) => {\n                return value;\n            },\n            parser: (value: string) => {\n                if (!value || typeof value !== 'string' || !inputFormatRegex.test(value)) {\n                    return null;\n                }\n                const matches = value.match(inputFormatRegex);\n                const year = +matches?.groups?.['yyyy'];\n                const month = +matches?.groups?.['MM'] - 1;\n                const day = +matches?.groups?.['dd'];\n                const date = new Date(year, month, day);\n\n                return date instanceof Date && !isNaN(<any>date)\n                    ? formatDate(date, outputFormat, 'en-US')\n                    : null;\n            }\n        });\n    }\n\n    currency(code: string, options?: Partial<CurrencyMaskOptions>) {\n        const locale = this._localize?.current?.locale ?? 'en';\n        const symbol = options?.symbol ?? getCurrencySymbol(code, options?.symbolFormat ?? 'narrow', locale);\n\n        const decimal = options?.decimalCharacter ?? getLocaleNumberSymbol(locale, NumberSymbol.CurrencyDecimal);\n        const group = options?.groupCharacter ?? getLocaleNumberSymbol(locale, NumberSymbol.CurrencyGroup);\n        const digits = options?.digits ?? getNumberOfCurrencyDigits(code);\n        const spacer = options?.spacer ?? ' ';\n\n        return createMask({\n            alias: 'numeric',\n            digits: digits,\n            allowMinus: options?.allowMinus ?? false,\n            min: options?.min ?? 0,\n            max: options?.max ?? Number.MAX_SAFE_INTEGER,\n            prefix: `${symbol}${spacer}`,\n            radixPoint: decimal ?? '.',\n            groupSeparator: group ?? ',',\n            digitsOptional: options?.digitsOptional ?? false,\n            nullable: options?.nullable ?? true,\n            autoUnmask: true,\n            unmaskAsNumber: true,\n            rightAlign: false,\n            showMaskOnHover: false,\n            showMaskOnFocus: false,\n            inputmode: digits > 0 ? 'decimal' : 'numeric',\n            parser: (value: string | number) => {\n                if (value === '') {\n                    return null;\n                }\n                return value;\n            }\n        });\n    }\n\n    private getDateParts(format: DateMaskFormat) {\n        switch (format) {\n            case 'day-month-year':\n                return ['dd', 'MM', 'yyyy'];\n            case 'month-day-year':\n                return ['MM', 'dd', 'yyyy'];\n            case 'year-day-month':\n                return ['yyyy', 'dd', 'MM'];\n            case 'year-month-day':\n            default:\n                return ['yyyy', 'MM', 'dd'];\n        }\n    }\n\n}\n"]}