@colijnit/corecomponents_v12 255.1.1 → 255.1.2

package/esm2015/lib/components/core-dialog/confirmation-dialog/confirmation-dialog.component.js

@@ -0,0 +1,79 @@
+import { Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import { IconCacheService } from '../../icon/icon-cache.service';
+import { CoreComponentsIcon } from '../../../core/enum/core-components-icon.enum';
+import { AppPopupType } from '../../../model/enum/app-popup-type.enum';
+import { AppPopupButtonType } from '../../../model/enum/app-button-type.enum';
+import { DialogBaseComponent } from '../../base/dialog-base.component';
+export class ConfirmationDialogComponent extends DialogBaseComponent {
+    constructor(iconCacheService) {
+        super();
+        this.iconCacheService = iconCacheService;
+        this.icons = CoreComponentsIcon;
+        this.ptype = AppPopupType;
+        this.showRememberCheckbox = false;
+        this.rememberChoice = false;
+    }
+    showClass() {
+        return true;
+    }
+    handleYesClick(event) {
+        this.onClose(AppPopupButtonType.Yes, undefined, this.rememberChoice);
+    }
+    handleNoClick(event) {
+        this.onClose(AppPopupButtonType.No, undefined, this.rememberChoice);
+    }
+    handleOkClick(event) {
+        this.onClose(AppPopupButtonType.Ok, undefined, this.rememberChoice);
+    }
+}
+ConfirmationDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-confirmation-dialog",
+                template: `
+    <co-dialog [showCloseIcon]="false" [headerTemplate]="headerTemplate" [footerTemplate]="footerTemplate">
+      <div class="confirmation-dialog-wrapper">
+        <div class="text" [innerHTML]="text"></div>
+        <co-collapsible [headerTitle]="'DETAILS' | coreLocalize" [iconData]="iconCacheService.getIcon(icons.TriangleDown)" *ngIf="details">
+          <div class="dialog-details" [innerHTML]="details"></div>
+        </co-collapsible>
+      </div>
+    </co-dialog>
+    <ng-template #headerTemplate>
+      <div class="co-dialog-header-title" [textContent]="title"></div>
+    </ng-template>
+    <ng-template #footerTemplate>
+      <div class="co-dialog-footer-button-wrapper">
+        <ng-container *ngIf="type === ptype.Confirmation">
+          <co-button class="save-button"
+                     [label]="'YES' | coreLocalize"
+                     (click)="handleYesClick($event)"></co-button>
+          <co-button class="close-button"
+                     [label]="'NO' | coreLocalize"
+                     (click)="handleNoClick($event)"></co-button>
+        </ng-container>
+        <ng-container *ngIf="type === ptype.Information || type === ptype.Error || type === ptype.Warning">
+          <co-button class="save-button"
+                     [iconData]="iconCacheService.getIcon(icons.CheckDuotone)"
+                     (click)="handleYesClick($event)"></co-button>
+        </ng-container>
+      </div>
+      <ng-container *ngIf="showRememberCheckbox">
+        <co-input-checkbox [label]="'REMEMBER_CHOICE' | coreLocalize" [(model)]="rememberChoice"></co-input-checkbox>
+      </ng-container>
+    </ng-template>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+ConfirmationDialogComponent.ctorParameters = () => [
+    { type: IconCacheService }
+];
+ConfirmationDialogComponent.propDecorators = {
+    title: [{ type: Input }],
+    text: [{ type: Input }],
+    details: [{ type: Input }],
+    type: [{ type: Input }],
+    showRememberCheckbox: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ["class.co-confirmation-dialog",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/core-dialog/core-dialog.module.js

@@ -0,0 +1,39 @@
+import { NgModule } from '@angular/core';
+import { CoreDialogService } from './core-dialog.service';
+import { ConfirmationDialogComponent } from './confirmation-dialog/confirmation-dialog.component';
+import { CoDialogModule } from '../co-dialog/co-dialog.module';
+import { CollapsibleModule } from '../collapsible/collapsible.module';
+import { CoreComponentsTranslationModule } from '../../translation/core-components-translation.module';
+import { ButtonModule } from '../button/button.module';
+import { InputCheckboxModule } from '../input-checkbox/input-checkbox.module';
+import { CommonModule } from '@angular/common';
+export class CoreDialogModule {
+    static forRoot() {
+        return {
+            ngModule: CoreDialogModule,
+            providers: [
+                CoreDialogService
+            ]
+        };
+    }
+}
+CoreDialogModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    CoDialogModule,
+                    CollapsibleModule,
+                    CoreComponentsTranslationModule,
+                    ButtonModule,
+                    InputCheckboxModule
+                ],
+                declarations: [
+                    ConfirmationDialogComponent
+                ],
+                providers: [
+                    CoreDialogService
+                ],
+                exports: []
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/core-dialog/core-dialog.service.js

@@ -0,0 +1,67 @@
+import { __awaiter } from "tslib";
+import { ApplicationRef, ComponentFactoryResolver, Injectable, Injector } from '@angular/core';
+import { CoreDynamicComponentService } from './core-dynamic-component.service';
+import { AppPopupType } from '../../model/enum/app-popup-type.enum';
+import { ConfirmationDialogComponent } from './confirmation-dialog/confirmation-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./core-dynamic-component.service";
+export class CoreDialogService {
+    constructor(_compFactoryResolver, appRef, injector, dynamicComponentService) {
+        this._compFactoryResolver = _compFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this.dynamicComponentService = dynamicComponentService;
+        this._componentRefs = [];
+    }
+    showYesNo(title, text, showRememberChoice = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                title: title,
+                text: text,
+                type: AppPopupType.Confirmation,
+                showRememberCheckbox: showRememberChoice
+            };
+            return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+        });
+    }
+    showError(message, details) {
+        const data = {
+            title: 'ERROR',
+            text: message,
+            type: AppPopupType.Error
+        };
+        if (details) {
+            data.details = details;
+        }
+        return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+    }
+    showInformation(message) {
+        const data = {
+            title: 'INFORMATION',
+            text: message,
+            type: AppPopupType.Information
+        };
+        return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+    }
+    showWarning(message) {
+        const data = {
+            title: 'WARNING',
+            text: message,
+            type: AppPopupType.Warning
+        };
+        return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+    }
+}
+CoreDialogService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CoreDialogService_Factory() { return new CoreDialogService(i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.CoreDynamicComponentService)); }, token: CoreDialogService, providedIn: "root" });
+CoreDialogService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+CoreDialogService.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ApplicationRef },
+    { type: Injector },
+    { type: CoreDynamicComponentService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/core-dialog/core-dynamic-component.service.js

@@ -0,0 +1,93 @@
+import { ApplicationRef, ComponentFactoryResolver, Injectable, Injector } from "@angular/core";
+import * as i0 from "@angular/core";
+export class CoreDynamicComponentService {
+    constructor(_compFactoryResolver, appRef, injector) {
+        this._compFactoryResolver = _compFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this._componentRefs = [];
+    }
+    getComponentRefs() {
+        return this._componentRefs;
+    }
+    createAndReturnComponentRef(componentClass, inputs) {
+        return new Promise((resolve) => {
+            const componentRef = this._compFactoryResolver
+                .resolveComponentFactory(componentClass)
+                .create(this.injector);
+            if (inputs) {
+                for (let property in inputs) {
+                    if (inputs.hasOwnProperty(property)) {
+                        componentRef.instance[property] = inputs[property];
+                    }
+                }
+            }
+            this.appRef.attachView(componentRef.hostView);
+            const domElem = componentRef.hostView
+                .rootNodes[0];
+            document.body.appendChild(domElem);
+            componentRef.onDestroy(() => {
+                this.appRef.detachView(componentRef.hostView);
+            });
+            resolve(componentRef);
+        });
+    }
+    createComponent(componentClass, inputs, outputs, providers) {
+        return new Promise((resolve) => {
+            if (providers) {
+                Injector.create(providers, this.injector);
+            }
+            const componentRef = this._compFactoryResolver
+                .resolveComponentFactory(componentClass)
+                .create(this.injector);
+            this._componentRefs.push(componentRef);
+            if (inputs) {
+                for (let property in inputs) {
+                    if (inputs.hasOwnProperty(property)) {
+                        componentRef.instance[property] = inputs[property];
+                    }
+                }
+            }
+            if (outputs) {
+                for (let event in outputs) {
+                    if (outputs.hasOwnProperty(event)) {
+                        componentRef.instance[event].subscribe(() => outputs[event]());
+                    }
+                }
+            }
+            this.appRef.attachView(componentRef.hostView);
+            const domElem = componentRef.hostView
+                .rootNodes[0];
+            document.body.appendChild(domElem);
+            componentRef.onDestroy(() => {
+                this.appRef.detachView(componentRef.hostView);
+            });
+            componentRef.instance.onClose = (button, output, rememberChoice) => {
+                const idx = this._componentRefs.indexOf(componentRef);
+                this.appRef.detachView(componentRef.hostView);
+                this._componentRefs[idx] = undefined;
+                this._componentRefs.splice(idx, 1);
+                if (outputs) {
+                    for (let event in outputs) {
+                        if (outputs.hasOwnProperty(event)) {
+                            componentRef.instance[event].unsubscribe();
+                        }
+                    }
+                }
+                resolve({ button: button, output: output ? output : undefined, rememberChoice: rememberChoice });
+            };
+        });
+    }
+}
+CoreDynamicComponentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CoreDynamicComponentService_Factory() { return new CoreDynamicComponentService(i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i0.INJECTOR)); }, token: CoreDynamicComponentService, providedIn: "root" });
+CoreDynamicComponentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+CoreDynamicComponentService.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ApplicationRef },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core-dynamic-component.service.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/core-dialog/core-dynamic-component.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {ApplicationRef, ComponentFactoryResolver, ComponentRef, EmbeddedViewRef, Injectable, Injector, StaticProvider} from \"@angular/core\";\r\nimport {DialogResponseInterface} from '../../interfaces/dialog-response.interface';\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class CoreDynamicComponentService {\r\n\r\n  private _componentRefs: any[] = [];\r\n\r\n  constructor(\r\n    private _compFactoryResolver: ComponentFactoryResolver,\r\n    private appRef: ApplicationRef,\r\n    private injector: Injector\r\n  ) { }\r\n\r\n  public getComponentRefs(): ComponentRef<any>[] {\r\n    return this._componentRefs;\r\n  }\r\n\r\n  public createAndReturnComponentRef(componentClass: any, inputs?: any): Promise<any> {\r\n    return new Promise((resolve: Function) => {\r\n      const componentRef: any = this._compFactoryResolver\r\n        .resolveComponentFactory(componentClass)\r\n        .create(this.injector);\r\n\r\n      if (inputs) {\r\n        for (let property in inputs) {\r\n          if (inputs.hasOwnProperty(property)) {\r\n            componentRef.instance[property] = inputs[property];\r\n          }\r\n        }\r\n      }\r\n\r\n      this.appRef.attachView(componentRef.hostView);\r\n\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n        .rootNodes[0] as HTMLElement;\r\n\r\n      document.body.appendChild(domElem);\r\n      componentRef.onDestroy(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n      });\r\n      resolve(componentRef);\r\n    })\r\n  }\r\n\r\n  public createComponent(componentClass: any, inputs?: any, outputs?: any, providers?: StaticProvider[]): Promise<DialogResponseInterface> {\r\n    return new Promise((resolve: Function) => {\r\n      if (providers) {\r\n        Injector.create(providers, this.injector);\r\n      }\r\n      const componentRef: any = this._compFactoryResolver\r\n        .resolveComponentFactory(componentClass)\r\n        .create(this.injector);\r\n      this._componentRefs.push(componentRef);\r\n\r\n      if (inputs) {\r\n        for (let property in inputs) {\r\n          if (inputs.hasOwnProperty(property)) {\r\n            componentRef.instance[property] = inputs[property];\r\n          }\r\n        }\r\n      }\r\n\r\n      if (outputs) {\r\n        for (let event in outputs) {\r\n          if (outputs.hasOwnProperty(event)) {\r\n            componentRef.instance[event].subscribe(() => outputs[event]());\r\n          }\r\n        }\r\n      }\r\n\r\n      this.appRef.attachView(componentRef.hostView);\r\n\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n        .rootNodes[0] as HTMLElement;\r\n\r\n      document.body.appendChild(domElem);\r\n      componentRef.onDestroy(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n      });\r\n\r\n      componentRef.instance.onClose = (button: any, output?: any, rememberChoice?: boolean) => {\r\n        const idx: number = this._componentRefs.indexOf(componentRef);\r\n        this.appRef.detachView(componentRef.hostView);\r\n        this._componentRefs[idx] = undefined;\r\n        this._componentRefs.splice(idx, 1);\r\n\r\n        if (outputs) {\r\n          for (let event in outputs) {\r\n            if (outputs.hasOwnProperty(event)) {\r\n              componentRef.instance[event].unsubscribe();\r\n            }\r\n          }\r\n        }\r\n        resolve({button: button, output: output ? output : undefined, rememberChoice: rememberChoice});\r\n      }\r\n    })\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/double-calendar/double-calendar.component.js

@@ -0,0 +1,80 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { BaseInputDatePickerDirective } from "../base-input-date-picker/base-input-date-picker.directive";
+export class DoubleCalendarComponent extends BaseInputDatePickerDirective {
+    constructor() {
+        super(...arguments);
+        this.selectedDates = [undefined, undefined];
+        this.datesSelected = new EventEmitter();
+        this.secondDateSelected = new EventEmitter();
+        this.clickedOutside = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        this.selectedFirstDate = this.selectedDates[0];
+        this.selectedSecondDate = this.selectedDates[1];
+    }
+    handleFirstDateSelected(date) {
+        this.selectedFirstDate = date;
+        this.selectedDates[0] = date;
+        if (this.selectedSecondDate && this.selectedFirstDate.getTime() > this.selectedSecondDate.getTime()) {
+            this.selectedSecondDate = null;
+        }
+        this.outputRangeIfValid();
+    }
+    handleSecondDateSelected(date) {
+        this.selectedSecondDate = date;
+        this.selectedDates[1] = date;
+        if (this.selectedFirstDate && this.selectedSecondDate.getTime() < this.selectedFirstDate.getTime()) {
+            this.selectedFirstDate = null;
+            this.selectedSecondDate = null;
+            this.secondHoveringDate = null;
+        }
+        if (this.selectedSecondDate && this.selectedDates[0] instanceof Date) {
+            this.outputRangeIfValid();
+            this.secondDateSelected.next();
+        }
+    }
+    outputRangeIfValid() {
+        if (this.selectedDates[0] instanceof Date && this.selectedDates[1] instanceof Date) {
+            this.datesSelected.next(this.selectedDates);
+        }
+    }
+    handleSecondHoveringDate(day) {
+        this.secondHoveringDate = day;
+    }
+}
+DoubleCalendarComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-double-calendar",
+                template: `
+    <div class="dual-calendar-wrapper" [overlay]="parentForOverlay" (clickOutside)="clickedOutside.next()">
+      <calendar-template
+        [selectedDate]="selectedFirstDate"
+        [secondSelectedDate]="selectedSecondDate"
+        [secondHoveringDate]="secondHoveringDate"
+        [highlightDaysBetweenDates]="true"
+        (dateSelected)="handleFirstDateSelected($event)"
+      ></calendar-template>
+      <calendar-template
+        [selectedDate]="selectedSecondDate"
+        [secondSelectedDate]="selectedFirstDate"
+        [highlightDaysBetweenDates]="true"
+        (hoveringDate)="handleSecondHoveringDate($event)"
+        (dateSelected)="handleSecondDateSelected($event)"
+      ></calendar-template>
+    </div>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+DoubleCalendarComponent.propDecorators = {
+    selectedDates: [{ type: Input }],
+    parentForOverlay: [{ type: Input }],
+    datesSelected: [{ type: Output }],
+    secondDateSelected: [{ type: Output }],
+    clickedOutside: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-double-calendar",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/double-calendar/double-calendar.module.js

@@ -0,0 +1,25 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { DoubleCalendarComponent } from "./double-calendar.component";
+import { CalendarModule } from "../calendar/calendar.module";
+import { OverlayModule } from "../../directives/overlay/overlay.module";
+import { ClickoutsideModule } from "../../directives/clickoutside/clickoutside.module";
+export class DoubleCalendarModule {
+}
+DoubleCalendarModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    CalendarModule,
+                    OverlayModule,
+                    ClickoutsideModule
+                ],
+                declarations: [
+                    DoubleCalendarComponent
+                ],
+                exports: [
+                    DoubleCalendarComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG91YmxlLWNhbGVuZGFyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9kb3VibGUtY2FsZW5kYXIvZG91YmxlLWNhbGVuZGFyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsdUJBQXVCLEVBQUMsTUFBTSw2QkFBNkIsQ0FBQztBQUNwRSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sNkJBQTZCLENBQUM7QUFDM0QsT0FBTyxFQUFDLGFBQWEsRUFBQyxNQUFNLHlDQUF5QyxDQUFDO0FBQ3RFLE9BQU8sRUFBQyxrQkFBa0IsRUFBQyxNQUFNLG1EQUFtRCxDQUFDO0FBZ0JyRixNQUFNLE9BQU8sb0JBQW9COzs7WUFkaEMsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO29CQUNaLGNBQWM7b0JBQ2QsYUFBYTtvQkFDYixrQkFBa0I7aUJBQ25CO2dCQUNELFlBQVksRUFBRTtvQkFDWix1QkFBdUI7aUJBQ3hCO2dCQUNELE9BQU8sRUFBRTtvQkFDUCx1QkFBdUI7aUJBQ3hCO2FBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge05nTW9kdWxlfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xyXG5pbXBvcnQge0RvdWJsZUNhbGVuZGFyQ29tcG9uZW50fSBmcm9tIFwiLi9kb3VibGUtY2FsZW5kYXIuY29tcG9uZW50XCI7XHJcbmltcG9ydCB7Q2FsZW5kYXJNb2R1bGV9IGZyb20gXCIuLi9jYWxlbmRhci9jYWxlbmRhci5tb2R1bGVcIjtcclxuaW1wb3J0IHtPdmVybGF5TW9kdWxlfSBmcm9tIFwiLi4vLi4vZGlyZWN0aXZlcy9vdmVybGF5L292ZXJsYXkubW9kdWxlXCI7XHJcbmltcG9ydCB7Q2xpY2tvdXRzaWRlTW9kdWxlfSBmcm9tIFwiLi4vLi4vZGlyZWN0aXZlcy9jbGlja291dHNpZGUvY2xpY2tvdXRzaWRlLm1vZHVsZVwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBpbXBvcnRzOiBbXHJcbiAgICBDb21tb25Nb2R1bGUsXHJcbiAgICBDYWxlbmRhck1vZHVsZSxcclxuICAgIE92ZXJsYXlNb2R1bGUsXHJcbiAgICBDbGlja291dHNpZGVNb2R1bGVcclxuICBdLFxyXG4gIGRlY2xhcmF0aW9uczogW1xyXG4gICAgRG91YmxlQ2FsZW5kYXJDb21wb25lbnRcclxuICBdLFxyXG4gIGV4cG9ydHM6IFtcclxuICAgIERvdWJsZUNhbGVuZGFyQ29tcG9uZW50XHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgRG91YmxlQ2FsZW5kYXJNb2R1bGUge1xyXG59XHJcbiJdfQ==

package/esm2015/lib/components/filter-item/filter-item-viewmodel.js

@@ -0,0 +1,13 @@
+import { NumberUtils } from "../../core/utils/number-utils";
+export class FilterItemViewmodel {
+    constructor(code, description, checked, count, valueName) {
+        this.checked = false;
+        this.code = code;
+        this.description = description === null || description === void 0 ? void 0 : description.toString();
+        this.checked = checked;
+        this.count = count;
+        this.valueName = valueName;
+    }
+    codeAsNumber() { return NumberUtils.ParseInt(this.code); }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsdGVyLWl0ZW0tdmlld21vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2ZpbHRlci1pdGVtL2ZpbHRlci1pdGVtLXZpZXdtb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sK0JBQStCLENBQUM7QUFFMUQsTUFBTSxPQUFPLG1CQUFtQjtJQVU5QixZQUFZLElBQXFCLEVBQUUsV0FBNEIsRUFBRSxPQUFnQixFQUFFLEtBQWMsRUFBRSxTQUFrQjtRQVI5RyxZQUFPLEdBQVksS0FBSyxDQUFDO1FBUzlCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO1FBQ2pCLElBQUksQ0FBQyxXQUFXLEdBQUcsV0FBVyxhQUFYLFdBQVcsdUJBQVgsV0FBVyxDQUFFLFFBQVEsRUFBRSxDQUFDO1FBQzNDLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxTQUFTLEdBQUcsU0FBUyxDQUFDO0lBQzdCLENBQUM7SUFSRCxZQUFZLEtBQWMsT0FBTyxXQUFXLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFBLENBQUM7Q0FTbkUiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge051bWJlclV0aWxzfSBmcm9tIFwiLi4vLi4vY29yZS91dGlscy9udW1iZXItdXRpbHNcIjtcclxuXHJcbmV4cG9ydCBjbGFzcyBGaWx0ZXJJdGVtVmlld21vZGVsIHtcclxuXHJcbiAgcHVibGljIGNoZWNrZWQ6IGJvb2xlYW4gPSBmYWxzZTtcclxuICBwdWJsaWMgY29kZTogc3RyaW5nIHwgbnVtYmVyO1xyXG4gIHB1YmxpYyBkZXNjcmlwdGlvbjogc3RyaW5nO1xyXG4gIHB1YmxpYyBjb3VudD86IG51bWJlcjtcclxuICBwdWJsaWMgdmFsdWVOYW1lPzogc3RyaW5nO1xyXG5cclxuICBjb2RlQXNOdW1iZXI/KCk6IG51bWJlciB7IHJldHVybiBOdW1iZXJVdGlscy5QYXJzZUludCh0aGlzLmNvZGUpO31cclxuXHJcbiAgY29uc3RydWN0b3IoY29kZTogc3RyaW5nIHwgbnVtYmVyLCBkZXNjcmlwdGlvbjogc3RyaW5nIHwgbnVtYmVyLCBjaGVja2VkOiBib29sZWFuLCBjb3VudD86IG51bWJlciwgdmFsdWVOYW1lPzogc3RyaW5nKSB7XHJcbiAgICB0aGlzLmNvZGUgPSBjb2RlO1xyXG4gICAgdGhpcy5kZXNjcmlwdGlvbiA9IGRlc2NyaXB0aW9uPy50b1N0cmluZygpO1xyXG4gICAgdGhpcy5jaGVja2VkID0gY2hlY2tlZDtcclxuICAgIHRoaXMuY291bnQgPSBjb3VudDtcclxuICAgIHRoaXMudmFsdWVOYW1lID0gdmFsdWVOYW1lO1xyXG4gIH1cclxufVxyXG4iXX0=