cax-design-system 1.0.0

package/esm2022/utils/public_api.mjs

@@ -0,0 +1,5 @@
+import { ObjectUtils } from './objectutils';
+import { UniqueComponentId } from './uniquecomponentid';
+import ZIndexUtils from './zindexutils';
+export { ZIndexUtils, UniqueComponentId, ObjectUtils };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy91dGlscy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDNUMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDeEQsT0FBTyxXQUFXLE1BQU0sZUFBZSxDQUFDO0FBRXhDLE9BQU8sRUFBRSxXQUFXLEVBQUUsaUJBQWlCLEVBQUUsV0FBVyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYmplY3RVdGlscyB9IGZyb20gJy4vb2JqZWN0dXRpbHMnO1xuaW1wb3J0IHsgVW5pcXVlQ29tcG9uZW50SWQgfSBmcm9tICcuL3VuaXF1ZWNvbXBvbmVudGlkJztcbmltcG9ydCBaSW5kZXhVdGlscyBmcm9tICcuL3ppbmRleHV0aWxzJztcblxuZXhwb3J0IHsgWkluZGV4VXRpbHMsIFVuaXF1ZUNvbXBvbmVudElkLCBPYmplY3RVdGlscyB9O1xuIl19

package/esm2022/utils/uniquecomponentid.mjs

@@ -0,0 +1,6 @@
+export var lastId = 0;
+export function UniqueComponentId(prefix = 'cx_id_') {
+    lastId++;
+    return `${prefix}${lastId}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5pcXVlY29tcG9uZW50aWQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXBwL2NvbXBvbmVudHMvdXRpbHMvdW5pcXVlY29tcG9uZW50aWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLElBQUksTUFBTSxHQUFHLENBQUMsQ0FBQztBQUV0QixNQUFNLFVBQVUsaUJBQWlCLENBQUMsTUFBTSxHQUFHLFFBQVE7SUFDL0MsTUFBTSxFQUFFLENBQUM7SUFFVCxPQUFPLEdBQUcsTUFBTSxHQUFHLE1BQU0sRUFBRSxDQUFDO0FBQ2hDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdmFyIGxhc3RJZCA9IDA7XG5cbmV4cG9ydCBmdW5jdGlvbiBVbmlxdWVDb21wb25lbnRJZChwcmVmaXggPSAnY3hfaWRfJykge1xuICAgIGxhc3RJZCsrO1xuXG4gICAgcmV0dXJuIGAke3ByZWZpeH0ke2xhc3RJZH1gO1xufVxuIl19

package/esm2022/utils/zindexutils.mjs

@@ -0,0 +1,35 @@
+function ZIndexUtils() {
+    let zIndexes = [];
+    const generateZIndex = (key, baseZIndex) => {
+        let lastZIndex = zIndexes.length > 0 ? zIndexes[zIndexes.length - 1] : { key, value: baseZIndex };
+        let newZIndex = lastZIndex.value + (lastZIndex.key === key ? 0 : baseZIndex) + 2;
+        zIndexes.push({ key, value: newZIndex });
+        return newZIndex;
+    };
+    const revertZIndex = (zIndex) => {
+        zIndexes = zIndexes.filter((obj) => obj.value !== zIndex);
+    };
+    const getCurrentZIndex = () => {
+        return zIndexes.length > 0 ? zIndexes[zIndexes.length - 1].value : 0;
+    };
+    const getZIndex = (el) => {
+        return el ? parseInt(el.style.zIndex, 10) || 0 : 0;
+    };
+    return {
+        get: getZIndex,
+        set: (key, el, baseZIndex) => {
+            if (el) {
+                el.style.zIndex = String(generateZIndex(key, baseZIndex));
+            }
+        },
+        clear: (el) => {
+            if (el) {
+                revertZIndex(getZIndex(el));
+                el.style.zIndex = '';
+            }
+        },
+        getCurrent: () => getCurrentZIndex()
+    };
+}
+export default ZIndexUtils();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/virtualscroller/cax-design-system-virtualscroller.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2F4LWRlc2lnbi1zeXN0ZW0tdmlydHVhbHNjcm9sbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2FwcC9jb21wb25lbnRzL3ZpcnR1YWxzY3JvbGxlci9jYXgtZGVzaWduLXN5c3RlbS12aXJ0dWFsc2Nyb2xsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2022/virtualscroller/public_api.mjs

@@ -0,0 +1,3 @@
+export * from './virtualscroller';
+export * from './virtualscroller.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9hcHAvY29tcG9uZW50cy92aXJ0dWFsc2Nyb2xsZXIvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3ZpcnR1YWxzY3JvbGxlcic7XG5leHBvcnQgKiBmcm9tICcuL3ZpcnR1YWxzY3JvbGxlci5pbnRlcmZhY2UnO1xuIl19

package/esm2022/virtualscroller/virtualscroller.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/virtualscroller/virtualscroller.mjs

@@ -0,0 +1,215 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, ContentChildren, EventEmitter, Input, NgModule, Output, ViewChild, ViewEncapsulation, booleanAttribute, numberAttribute } from '@angular/core';
+import { Footer, Header, CaxTemplate, SharedModule } from 'cax-design-system/api';
+import { ScrollerModule } from 'cax-design-system/scroller';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "cax-design-system/api";
+import * as i3 from "cax-design-system/scroller";
+/**
+ * VirtualScroller is a performant approach to handle huge data efficiently.
+ * @group Components
+ */
+export class VirtualScroller {
+    el;
+    cd;
+    /**
+     * An array of objects to display.
+     * @group Props
+     */
+    value;
+    /**
+     * Height of an item in the list.
+     * @group Props
+     */
+    itemSize;
+    /**
+     * Inline style of the component.
+     * @group Props
+     */
+    style;
+    /**
+     * Style class of the component.
+     * @group Props
+     */
+    styleClass;
+    /**
+     * Max height of the content area in inline mode.
+     * @group Props
+     */
+    scrollHeight;
+    /**
+     * Defines if data is loaded and interacted with in lazy manner.
+     * @group Props
+     */
+    lazy;
+    /**
+     * Whether to use the scroller feature. The properties of scroller component can be used like an object in it.
+     * @group Props
+     */
+    options;
+    /**
+     * Threshold in milliseconds to delay lazy loading during scrolling.
+     * @group Props
+     */
+    delay = 250;
+    /**
+     * Callback to invoke in lazy mode to load new data.
+     * @param {VirtualScrollerLazyLoadEvent} event - custom lazy load event.
+     * @group Emits
+     */
+    onLazyLoad = new EventEmitter();
+    header;
+    footer;
+    templates;
+    scroller;
+    itemTemplate;
+    headerTemplate;
+    footerTemplate;
+    loadingItemTemplate;
+    virtualScrollTimeout;
+    constructor(el, cd) {
+        this.el = el;
+        this.cd = cd;
+    }
+    ngAfterContentInit() {
+        this.templates.forEach((item) => {
+            switch (item.getType()) {
+                case 'item':
+                    this.itemTemplate = item.template;
+                    break;
+                case 'loadingItem':
+                    this.loadingItemTemplate = item.template;
+                    break;
+                case 'header':
+                    this.headerTemplate = item.template;
+                    break;
+                case 'footer':
+                    this.footerTemplate = item.template;
+                    break;
+                default:
+                    this.itemTemplate = item.template;
+                    break;
+            }
+        });
+    }
+    onLazyItemLoad(event) {
+        if (this.virtualScrollTimeout) {
+            clearTimeout(this.virtualScrollTimeout);
+        }
+        this.virtualScrollTimeout = setTimeout(() => {
+            this.onLazyLoad.emit({
+                ...event,
+                rows: event.last - event.first,
+                forceUpdate: () => this.cd.detectChanges()
+            });
+        }, this.delay);
+    }
+    getBlockableElement() {
+        return this.el.nativeElement.children[0];
+    }
+    scrollToIndex(index, mode) {
+        this.scroller?.scrollToIndex(index, mode);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScroller, deps: [{ token: i0.ElementRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "16.1.0", version: "18.2.9", type: VirtualScroller, selector: "p-virtualScroller", inputs: { value: "value", itemSize: ["itemSize", "itemSize", numberAttribute], style: "style", styleClass: "styleClass", scrollHeight: "scrollHeight", lazy: ["lazy", "lazy", booleanAttribute], options: "options", delay: ["delay", "delay", numberAttribute] }, outputs: { onLazyLoad: "onLazyLoad" }, host: { classAttribute: "cax-element" }, queries: [{ propertyName: "header", first: true, predicate: Header, descendants: true }, { propertyName: "footer", first: true, predicate: Footer, descendants: true }, { propertyName: "templates", predicate: CaxTemplate }], viewQueries: [{ propertyName: "scroller", first: true, predicate: ["scroller"], descendants: true }], ngImport: i0, template: `
+        <div [ngClass]="'p-virtualscroller p-component'" [ngStyle]="style" [class]="styleClass" [attr.data-pc-name]="'virtualscroller'" [attr.data-pc-section]="'root'">
+            <div class="p-virtualscroller-header" *ngIf="header || headerTemplate">
+                <ng-content select="cax-header"></ng-content>
+                <ng-container *ngTemplateOutlet="headerTemplate"></ng-container>
+            </div>
+            <div #content class="p-virtualscroller-content" [attr.data-pc-section]="'content'">
+                <cax-scroller #scroller [items]="value" styleClass="p-virtualscroller-list" [style]="{ height: scrollHeight }" [itemSize]="itemSize" [lazy]="lazy" (onLazyLoad)="onLazyItemLoad($event)" [options]="options">
+                    <ng-template caxTemplate="item" let-item let-scrollerOptions="options">
+                        <div [ngStyle]="{ height: itemSize + 'px' }" class="p-virtualscroller-item">
+                            <ng-container *ngTemplateOutlet="item ? itemTemplate : loadingItemTemplate; context: { $implicit: item, options: scrollerOptions }"></ng-container>
+                        </div>
+                    </ng-template>
+                </cax-scroller>
+            </div>
+            <div class="p-virtualscroller-footer" *ngIf="footer || footerTemplate" [attr.data-pc-section]="'footer'">
+                <ng-content select="cax-footer"></ng-content>
+                <ng-container *ngTemplateOutlet="footerTemplate"></ng-container>
+            </div>
+        </div>
+    `, isInline: true, dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i2.CaxTemplate, selector: "[caxTemplate]", inputs: ["type", "caxTemplate"] }, { kind: "component", type: i3.Scroller, selector: "cax-scroller", inputs: ["id", "style", "styleClass", "tabindex", "items", "itemSize", "scrollHeight", "scrollWidth", "orientation", "step", "delay", "resizeDelay", "appendOnly", "inline", "lazy", "disabled", "loaderDisabled", "columns", "showSpacer", "showLoader", "numToleratedItems", "loading", "autoSize", "trackBy", "options"], outputs: ["onLazyLoad", "onScroll", "onScrollIndexChange"] }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScroller, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'p-virtualScroller',
+                    template: `
+        <div [ngClass]="'p-virtualscroller p-component'" [ngStyle]="style" [class]="styleClass" [attr.data-pc-name]="'virtualscroller'" [attr.data-pc-section]="'root'">
+            <div class="p-virtualscroller-header" *ngIf="header || headerTemplate">
+                <ng-content select="cax-header"></ng-content>
+                <ng-container *ngTemplateOutlet="headerTemplate"></ng-container>
+            </div>
+            <div #content class="p-virtualscroller-content" [attr.data-pc-section]="'content'">
+                <cax-scroller #scroller [items]="value" styleClass="p-virtualscroller-list" [style]="{ height: scrollHeight }" [itemSize]="itemSize" [lazy]="lazy" (onLazyLoad)="onLazyItemLoad($event)" [options]="options">
+                    <ng-template caxTemplate="item" let-item let-scrollerOptions="options">
+                        <div [ngStyle]="{ height: itemSize + 'px' }" class="p-virtualscroller-item">
+                            <ng-container *ngTemplateOutlet="item ? itemTemplate : loadingItemTemplate; context: { $implicit: item, options: scrollerOptions }"></ng-container>
+                        </div>
+                    </ng-template>
+                </cax-scroller>
+            </div>
+            <div class="p-virtualscroller-footer" *ngIf="footer || footerTemplate" [attr.data-pc-section]="'footer'">
+                <ng-content select="cax-footer"></ng-content>
+                <ng-container *ngTemplateOutlet="footerTemplate"></ng-container>
+            </div>
+        </div>
+    `,
+                    changeDetection: ChangeDetectionStrategy.Default,
+                    encapsulation: ViewEncapsulation.None,
+                    host: {
+                        class: 'cax-element'
+                    }
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.ChangeDetectorRef }], propDecorators: { value: [{
+                type: Input
+            }], itemSize: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], style: [{
+                type: Input
+            }], styleClass: [{
+                type: Input
+            }], scrollHeight: [{
+                type: Input
+            }], lazy: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }], options: [{
+                type: Input
+            }], delay: [{
+                type: Input,
+                args: [{ transform: numberAttribute }]
+            }], onLazyLoad: [{
+                type: Output
+            }], header: [{
+                type: ContentChild,
+                args: [Header]
+            }], footer: [{
+                type: ContentChild,
+                args: [Footer]
+            }], templates: [{
+                type: ContentChildren,
+                args: [CaxTemplate]
+            }], scroller: [{
+                type: ViewChild,
+                args: ['scroller']
+            }] } });
+export class VirtualScrollerModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScrollerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.9", ngImport: i0, type: VirtualScrollerModule, declarations: [VirtualScroller], imports: [CommonModule, SharedModule, ScrollerModule], exports: [VirtualScroller, SharedModule, ScrollerModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScrollerModule, imports: [CommonModule, SharedModule, ScrollerModule, SharedModule, ScrollerModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: VirtualScrollerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, SharedModule, ScrollerModule],
+                    exports: [VirtualScroller, SharedModule, ScrollerModule],
+                    declarations: [VirtualScroller]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtualscroller.js","sourceRoot":"","sources":["../../../src/app/components/virtualscroller/virtualscroller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAEH,uBAAuB,EAEvB,SAAS,EACT,YAAY,EACZ,eAAe,EAEf,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,MAAM,EAGN,SAAS,EACT,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAe,MAAM,EAAE,MAAM,EAAE,WAAW,EAAmB,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAChH,OAAO,EAAY,cAAc,EAAE,MAAM,4BAA4B,CAAC;;;;;AAGtE;;;GAGG;AA8BH,MAAM,OAAO,eAAe;IAmEb;IACA;IAnEX;;;OAGG;IACM,KAAK,CAAoB;IAClC;;;OAGG;IACoC,QAAQ,CAAqB;IACpE;;;OAGG;IACM,KAAK,CAA8C;IAC5D;;;OAGG;IACM,UAAU,CAAqB;IACxC;;;OAGG;IACM,YAAY,CAAM;IAC3B;;;OAGG;IACqC,IAAI,CAAsB;IAClE;;;OAGG;IACM,OAAO,CAA8B;IAC9C;;;OAGG;IACoC,KAAK,GAAW,GAAG,CAAC;IAC3D;;;;OAIG;IACO,UAAU,GAA+C,IAAI,YAAY,EAAgC,CAAC;IAE9F,MAAM,CAAqB;IAE3B,MAAM,CAAqB;IAEnB,SAAS,CAAmC;IAEnD,QAAQ,CAAqB;IAEpD,YAAY,CAA6B;IAEzC,cAAc,CAA6B;IAE3C,cAAc,CAA6B;IAE3C,mBAAmB,CAA6B;IAEhD,oBAAoB,CAAM;IAE1B,YACW,EAAc,EACd,EAAqB;QADrB,OAAE,GAAF,EAAE,CAAY;QACd,OAAE,GAAF,EAAE,CAAmB;IAC7B,CAAC;IAEJ,kBAAkB;QACb,IAAI,CAAC,SAAoC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACxD,QAAQ,IAAI,CAAC,OAAO,EAAE,EAAE,CAAC;gBACrB,KAAK,MAAM;oBACP,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAClC,MAAM;gBAEV,KAAK,aAAa;oBACd,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACzC,MAAM;gBAEV,KAAK,QAAQ;oBACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACpC,MAAM;gBAEV,KAAK,QAAQ;oBACT,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC;oBACpC,MAAM;gBAEV;oBACI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC;oBAClC,MAAM;YACd,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED,cAAc,CAAC,KAAmC;QAC9C,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC5B,YAAY,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;QAC5C,CAAC;QAED,IAAI,CAAC,oBAAoB,GAAG,UAAU,CAAC,GAAG,EAAE;YACxC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;gBACjB,GAAG,KAAK;gBACR,IAAI,EAAU,KAAK,CAAC,IAAI,GAAW,KAAK,CAAC,KAAK;gBAC9C,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,EAAE;aAC7C,CAAC,CAAC;QACP,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAED,mBAAmB;QACf,OAAO,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAC7C,CAAC;IAED,aAAa,CAAC,KAAa,EAAE,IAAqB;QAC9C,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9C,CAAC;uGArHQ,eAAe;2FAAf,eAAe,8FAUJ,eAAe,kGAoBf,gBAAgB,iDAUhB,eAAe,iJAQrB,MAAM,yEAEN,MAAM,+DAEH,WAAW,mIA/ElB;;;;;;;;;;;;;;;;;;;;KAoBT;;2FAOQ,eAAe;kBA7B3B,SAAS;mBAAC;oBACP,QAAQ,EAAE,mBAAmB;oBAC7B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;KAoBT;oBACD,eAAe,EAAE,uBAAuB,CAAC,OAAO;oBAChD,aAAa,EAAE,iBAAiB,CAAC,IAAI;oBACrC,IAAI,EAAE;wBACF,KAAK,EAAE,aAAa;qBACvB;iBACJ;+GAMY,KAAK;sBAAb,KAAK;gBAKiC,QAAQ;sBAA9C,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAK5B,KAAK;sBAAb,KAAK;gBAKG,UAAU;sBAAlB,KAAK;gBAKG,YAAY;sBAApB,KAAK;gBAKkC,IAAI;sBAA3C,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE;gBAK7B,OAAO;sBAAf,KAAK;gBAKiC,KAAK;sBAA3C,KAAK;uBAAC,EAAE,SAAS,EAAE,eAAe,EAAE;gBAM3B,UAAU;sBAAnB,MAAM;gBAEe,MAAM;sBAA3B,YAAY;uBAAC,MAAM;gBAEE,MAAM;sBAA3B,YAAY;uBAAC,MAAM;gBAEU,SAAS;sBAAtC,eAAe;uBAAC,WAAW;gBAEL,QAAQ;sBAA9B,SAAS;uBAAC,UAAU;;AAuEzB,MAAM,OAAO,qBAAqB;uGAArB,qBAAqB;wGAArB,qBAAqB,iBA7HrB,eAAe,aAyHd,YAAY,EAAE,YAAY,EAAE,cAAc,aAzH3C,eAAe,EA0HG,YAAY,EAAE,cAAc;wGAG9C,qBAAqB,YAJpB,YAAY,EAAE,YAAY,EAAE,cAAc,EACzB,YAAY,EAAE,cAAc;;2FAG9C,qBAAqB;kBALjC,QAAQ;mBAAC;oBACN,OAAO,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,cAAc,CAAC;oBACrD,OAAO,EAAE,CAAC,eAAe,EAAE,YAAY,EAAE,cAAc,CAAC;oBACxD,YAAY,EAAE,CAAC,eAAe,CAAC;iBAClC","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n    AfterContentInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ContentChild,\n    ContentChildren,\n    ElementRef,\n    EventEmitter,\n    Input,\n    NgModule,\n    Output,\n    QueryList,\n    TemplateRef,\n    ViewChild,\n    ViewEncapsulation,\n    booleanAttribute,\n    numberAttribute\n} from '@angular/core';\nimport { BlockableUI, Footer, Header, CaxTemplate, ScrollerOptions, SharedModule } from 'cax-design-system/api';\nimport { Scroller, ScrollerModule } from 'cax-design-system/scroller';\nimport { Nullable } from 'cax-design-system/ts-helpers';\nimport { VirtualScrollerLazyLoadEvent } from './virtualscroller.interface';\n/**\n * VirtualScroller is a performant approach to handle huge data efficiently.\n * @group Components\n */\n@Component({\n    selector: 'p-virtualScroller',\n    template: `\n        <div [ngClass]=\"'p-virtualscroller p-component'\" [ngStyle]=\"style\" [class]=\"styleClass\" [attr.data-pc-name]=\"'virtualscroller'\" [attr.data-pc-section]=\"'root'\">\n            <div class=\"p-virtualscroller-header\" *ngIf=\"header || headerTemplate\">\n                <ng-content select=\"cax-header\"></ng-content>\n                <ng-container *ngTemplateOutlet=\"headerTemplate\"></ng-container>\n            </div>\n            <div #content class=\"p-virtualscroller-content\" [attr.data-pc-section]=\"'content'\">\n                <cax-scroller #scroller [items]=\"value\" styleClass=\"p-virtualscroller-list\" [style]=\"{ height: scrollHeight }\" [itemSize]=\"itemSize\" [lazy]=\"lazy\" (onLazyLoad)=\"onLazyItemLoad($event)\" [options]=\"options\">\n                    <ng-template caxTemplate=\"item\" let-item let-scrollerOptions=\"options\">\n                        <div [ngStyle]=\"{ height: itemSize + 'px' }\" class=\"p-virtualscroller-item\">\n                            <ng-container *ngTemplateOutlet=\"item ? itemTemplate : loadingItemTemplate; context: { $implicit: item, options: scrollerOptions }\"></ng-container>\n                        </div>\n                    </ng-template>\n                </cax-scroller>\n            </div>\n            <div class=\"p-virtualscroller-footer\" *ngIf=\"footer || footerTemplate\" [attr.data-pc-section]=\"'footer'\">\n                <ng-content select=\"cax-footer\"></ng-content>\n                <ng-container *ngTemplateOutlet=\"footerTemplate\"></ng-container>\n            </div>\n        </div>\n    `,\n    changeDetection: ChangeDetectionStrategy.Default,\n    encapsulation: ViewEncapsulation.None,\n    host: {\n        class: 'cax-element'\n    }\n})\nexport class VirtualScroller implements AfterContentInit, BlockableUI {\n    /**\n     * An array of objects to display.\n     * @group Props\n     */\n    @Input() value: any[] | undefined;\n    /**\n     * Height of an item in the list.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) itemSize: number | undefined;\n    /**\n     * Inline style of the component.\n     * @group Props\n     */\n    @Input() style: { [klass: string]: any } | null | undefined;\n    /**\n     * Style class of the component.\n     * @group Props\n     */\n    @Input() styleClass: string | undefined;\n    /**\n     * Max height of the content area in inline mode.\n     * @group Props\n     */\n    @Input() scrollHeight: any;\n    /**\n     * Defines if data is loaded and interacted with in lazy manner.\n     * @group Props\n     */\n    @Input({ transform: booleanAttribute }) lazy: boolean | undefined;\n    /**\n     * Whether to use the scroller feature. The properties of scroller component can be used like an object in it.\n     * @group Props\n     */\n    @Input() options: ScrollerOptions | undefined;\n    /**\n     * Threshold in milliseconds to delay lazy loading during scrolling.\n     * @group Props\n     */\n    @Input({ transform: numberAttribute }) delay: number = 250;\n    /**\n     * Callback to invoke in lazy mode to load new data.\n     * @param {VirtualScrollerLazyLoadEvent} event - custom lazy load event.\n     * @group Emits\n     */\n    @Output() onLazyLoad: EventEmitter<VirtualScrollerLazyLoadEvent> = new EventEmitter<VirtualScrollerLazyLoadEvent>();\n\n    @ContentChild(Header) header: Header | undefined;\n\n    @ContentChild(Footer) footer: Footer | undefined;\n\n    @ContentChildren(CaxTemplate) templates: Nullable<QueryList<CaxTemplate>>;\n\n    @ViewChild('scroller') scroller: Nullable<Scroller>;\n\n    itemTemplate: Nullable<TemplateRef<any>>;\n\n    headerTemplate: Nullable<TemplateRef<any>>;\n\n    footerTemplate: Nullable<TemplateRef<any>>;\n\n    loadingItemTemplate: Nullable<TemplateRef<any>>;\n\n    virtualScrollTimeout: any;\n\n    constructor(\n        public el: ElementRef,\n        public cd: ChangeDetectorRef\n    ) {}\n\n    ngAfterContentInit() {\n        (this.templates as QueryList<CaxTemplate>).forEach((item) => {\n            switch (item.getType()) {\n                case 'item':\n                    this.itemTemplate = item.template;\n                    break;\n\n                case 'loadingItem':\n                    this.loadingItemTemplate = item.template;\n                    break;\n\n                case 'header':\n                    this.headerTemplate = item.template;\n                    break;\n\n                case 'footer':\n                    this.footerTemplate = item.template;\n                    break;\n\n                default:\n                    this.itemTemplate = item.template;\n                    break;\n            }\n        });\n    }\n\n    onLazyItemLoad(event: VirtualScrollerLazyLoadEvent) {\n        if (this.virtualScrollTimeout) {\n            clearTimeout(this.virtualScrollTimeout);\n        }\n\n        this.virtualScrollTimeout = setTimeout(() => {\n            this.onLazyLoad.emit({\n                ...event,\n                rows: <number>event.last - <number>event.first,\n                forceUpdate: () => this.cd.detectChanges()\n            });\n        }, this.delay);\n    }\n\n    getBlockableElement(): HTMLElement {\n        return this.el.nativeElement.children[0];\n    }\n\n    scrollToIndex(index: number, mode?: ScrollBehavior): void {\n        this.scroller?.scrollToIndex(index, mode);\n    }\n}\n\n@NgModule({\n    imports: [CommonModule, SharedModule, ScrollerModule],\n    exports: [VirtualScroller, SharedModule, ScrollerModule],\n    declarations: [VirtualScroller]\n})\nexport class VirtualScrollerModule {}\n"]}