@acorex/components 6.5.91 → 6.6.0

package/esm2022/lib/data-filter/filter.class.mjs

@@ -0,0 +1,46 @@
+import { Input, ChangeDetectorRef, EventEmitter, Output, Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AXFilterColumnComponent {
+    cdr;
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    operator = 'equal';
+    value = null;
+    field = null;
+    valueChange = new EventEmitter();
+    activeChange = new EventEmitter();
+    _active;
+    get active() {
+        return this._active;
+    }
+    set active(v) {
+        this._active = v;
+        this.activeChange.emit(v);
+    }
+    clear() {
+        this.active = false;
+        this.value = null;
+        this.cdr.detectChanges();
+    }
+    setFilter(value, operator) {
+        this.active = true;
+        this.operator = operator;
+        this.value = value;
+        this.cdr.detectChanges();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXFilterColumnComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AXFilterColumnComponent, inputs: { field: "field", active: "active" }, outputs: { valueChange: "valueChange", activeChange: "activeChange" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXFilterColumnComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { field: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], activeChange: [{
+                type: Output
+            }], active: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/data-filter/filter.module.mjs

@@ -0,0 +1,88 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { AXFilterPanelComponent } from './filter-panel/filter-panel.component';
+import { AXFilterColumnStringComponent } from './columns/filter-column-string.component';
+import { FormsModule } from '@angular/forms';
+import { AXFilterColumnSelectionComponent } from './columns/filter-column-selection.component';
+import { AXFilterColumnDateComponent } from './columns/filter-column-date.component';
+import { AXFilterColumnNumberComponent } from './columns/filter-column-number.component';
+import { AXToolbarFilterViewComponent } from './toolbar/filter-toolbar.component';
+import { AXPanelBoxModule } from '../panel-box/panel-box.module';
+import { AXDatePickerModule } from '../date-picker/date-picker.module';
+import { AXCheckBoxModule } from '../checkbox/checkbox.module';
+import { AXTextBoxModule } from '../textbox/textbox.module';
+import { AXToastModule } from '../toast/toast.module';
+import { AXToolbarModule } from '../toolbar/toolbar.module';
+import { AXMenuModule } from '../menu/menu.module';
+import { AXSelectionListModule } from '../selection-list/selection-list.module';
+import { AXButtonModule } from '../button/button.module';
+import { AXValidationModule } from '../validation/validation.module';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    AXFilterPanelComponent,
+    AXFilterColumnStringComponent,
+    AXFilterColumnSelectionComponent,
+    AXFilterColumnDateComponent,
+    AXFilterColumnNumberComponent,
+    AXToolbarFilterViewComponent,
+];
+export class AXFilterModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXFilterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AXFilterModule, declarations: [AXFilterPanelComponent,
+            AXFilterColumnStringComponent,
+            AXFilterColumnSelectionComponent,
+            AXFilterColumnDateComponent,
+            AXFilterColumnNumberComponent,
+            AXToolbarFilterViewComponent], imports: [CommonModule,
+            FormsModule,
+            AXPanelBoxModule,
+            AXDatePickerModule,
+            AXCheckBoxModule,
+            AXTextBoxModule,
+            AXValidationModule,
+            AXToastModule,
+            AXToolbarModule,
+            AXMenuModule,
+            AXSelectionListModule,
+            AXButtonModule], exports: [AXFilterPanelComponent,
+            AXFilterColumnStringComponent,
+            AXFilterColumnSelectionComponent,
+            AXFilterColumnDateComponent,
+            AXFilterColumnNumberComponent,
+            AXToolbarFilterViewComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXFilterModule, imports: [CommonModule,
+            FormsModule,
+            AXPanelBoxModule,
+            AXDatePickerModule,
+            AXCheckBoxModule,
+            AXTextBoxModule,
+            AXValidationModule,
+            AXToastModule,
+            AXToolbarModule,
+            AXMenuModule,
+            AXSelectionListModule,
+            AXButtonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXFilterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [COMPONENTS],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        AXPanelBoxModule,
+                        AXDatePickerModule,
+                        AXCheckBoxModule,
+                        AXTextBoxModule,
+                        AXValidationModule,
+                        AXToastModule,
+                        AXToolbarModule,
+                        AXMenuModule,
+                        AXSelectionListModule,
+                        AXButtonModule
+                    ],
+                    exports: [COMPONENTS],
+                    providers: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/data-filter/toolbar/filter-toolbar.component.mjs

@@ -0,0 +1,168 @@
+import { Component, Input, ViewChild, ViewEncapsulation } from '@angular/core';
+import { AXHtmlUtil } from '@acorex/core';
+import { AXFilterPanelComponent } from '../filter-panel/filter-panel.component';
+import { AXToolbarItem } from '../../toolbar/toolbar-item';
+import { AXToolbarMenuComponent } from '../../toolbar/menu/toolbar-menu.component';
+import { AXMenuComponent } from '../../menu/menu.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../toolbar/menu/toolbar-menu.component";
+import * as i2 from "../../menu/menu.component";
+export class AXToolbarFilterViewComponent {
+    constructor() { }
+    _uid = AXHtmlUtil.getUID();
+    menu;
+    contextMenu;
+    filterPanel;
+    contextMenuItems = [
+        // {
+        //     name: 'addFolder',
+        //     startIcon: 'fas fa-folder',
+        //     text: 'New Folder',
+        // },
+        {
+            name: 'remove',
+            startIcon: 'fas fa-trash',
+            text: 'Delete',
+        },
+    ];
+    menuItems = [
+        {
+            name: 'root',
+            startIcon: 'fas fa-filter',
+            text: 'Select All',
+            items: [
+                {
+                    name: 'selectAll',
+                    style: 'f',
+                    text: 'Select All',
+                },
+                // {
+                //     split: true,
+                //     name: 'addFolder',
+                //     startIcon: 'fas fa-folder',
+                //     text: 'New Folder',
+                // },
+                {
+                    divider: true,
+                    name: 'save',
+                    startIcon: 'fas fa-save',
+                    text: 'Save'
+                },
+                {
+                    divider: true,
+                    name: 'saveAs',
+                    startIcon: 'fas fa-save',
+                    text: 'Save As...'
+                }
+            ]
+        }
+    ];
+    ngAfterViewInit() {
+        setTimeout(() => {
+            this.selectAll();
+            this.addPredefinedList();
+        }, 100);
+    }
+    addPredefinedList() {
+        this.filterPanel.predefinedFilters.forEach(c => {
+            const item = {
+                name: c.name,
+                text: c.title,
+                type: 'f',
+                startIcon: 'fas',
+                data: c.value,
+                style: this._uid,
+                uid: AXHtmlUtil.getUID()
+            };
+            this.root.items.splice(1, 0, item);
+        });
+        this.update();
+    }
+    selectAll() {
+        this.setCurrent(this.root.items[0]);
+        this.filterPanel.clear();
+        this.update();
+        this.menu.close();
+        // this.contextMenu.close();
+    }
+    itemClick(e) {
+        if (e.style === 'f') {
+            if (e.name === 'selectAll') {
+                this.selectAll();
+            }
+            else {
+                this.setCurrent(e);
+                this.filterPanel.load(e.data);
+            }
+        }
+        else {
+            if (e.name === 'saveAs') {
+                const name = prompt('Please enter the name;');
+                if (name) {
+                    const item = {
+                        text: name,
+                        type: 'f',
+                        style: this._uid,
+                        startIcon: 'fas',
+                        data: this.filterPanel.value,
+                        uid: AXHtmlUtil.getUID()
+                    };
+                    this.root.items.splice(1, 0, item);
+                    this.setCurrent(item);
+                }
+            }
+            if (e.name === 'save') {
+                const selected = this.findSelected();
+                if (selected) {
+                    selected.data = this.filterPanel.value;
+                }
+            }
+        }
+        this.update();
+    }
+    findSelected() {
+        return this.root.items.find(c => c.selected);
+    }
+    get root() {
+        return this.menuItems[0];
+    }
+    update() {
+        this.menu.update();
+        setTimeout(() => {
+            // this.contextMenu.update();
+        }, 100);
+    }
+    setCurrent(e) {
+        this.root.text = e.text;
+        this.root.items.filter(c => c.style === 'f').forEach(c => {
+            c.selected = false;
+            c.startIcon = 'fas';
+        });
+        e.selected = true;
+        e.startIcon = 'fas fa-check';
+        this.root.items.find(c => c.name === 'save').visible = e.name !== 'selectAll';
+    }
+    onCtxClick(e) {
+        const target = this.contextMenu.currentTarget;
+        const menuId = target.getAttribute('data-uid');
+        if (e.name === 'remove' && menuId) {
+            this.root.items = this.root.items.filter(c => c.uid !== menuId);
+            this.selectAll();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXToolbarFilterViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AXToolbarFilterViewComponent, selector: "ax-toolbar-filter-view", inputs: { filterPanel: "filterPanel" }, providers: [{ provide: AXToolbarItem, useExisting: AXToolbarFilterViewComponent }], viewQueries: [{ propertyName: "menu", first: true, predicate: ["menu"], descendants: true, static: true }, { propertyName: "contextMenu", first: true, predicate: ["contextMenu"], descendants: true, static: true }], ngImport: i0, template: "<ax-toolbar-menu [items]=\"menuItems\" (onItemClick)=\"itemClick($event)\" #menu >\n   \n</ax-toolbar-menu>\n<ax-menu target=\".{{_uid}}\" [items]=\"contextMenuItems\"  direction=\"vertical\"  #contextMenu (onItemClick)=\"onCtxClick($event)\">\n</ax-menu>", styles: [".ax-toolbar-menu-item .icon-remove{visibility:hidden;color:var(--danger-color);margin-inline-start:25px;font-size:var(--font-sm-size)}.ax-toolbar-menu-item:hover>.icon-remove{visibility:unset}\n"], dependencies: [{ kind: "component", type: i1.AXToolbarMenuComponent, selector: "ax-toolbar-menu", inputs: ["menuTemplate", "selection", "items"], outputs: ["onItemClick"] }, { kind: "component", type: i2.AXMenuComponent, selector: "ax-menu", inputs: ["menuTemplate", "rtl", "size", "selection", "mode", "target", "floatAlignment", "floatPlacemnet", "direction", "items"], outputs: ["onItemClick"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXToolbarFilterViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ax-toolbar-filter-view', encapsulation: ViewEncapsulation.None, providers: [{ provide: AXToolbarItem, useExisting: AXToolbarFilterViewComponent }], template: "<ax-toolbar-menu [items]=\"menuItems\" (onItemClick)=\"itemClick($event)\" #menu >\n   \n</ax-toolbar-menu>\n<ax-menu target=\".{{_uid}}\" [items]=\"contextMenuItems\"  direction=\"vertical\"  #contextMenu (onItemClick)=\"onCtxClick($event)\">\n</ax-menu>", styles: [".ax-toolbar-menu-item .icon-remove{visibility:hidden;color:var(--danger-color);margin-inline-start:25px;font-size:var(--font-sm-size)}.ax-toolbar-menu-item:hover>.icon-remove{visibility:unset}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { menu: [{
+                type: ViewChild,
+                args: ['menu', { static: true }]
+            }], contextMenu: [{
+                type: ViewChild,
+                args: ['contextMenu', { static: true }]
+            }], filterPanel: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter-toolbar.component.js","sourceRoot":"","sources":["../../../../../../../libs/components/src/lib/data-filter/toolbar/filter-toolbar.component.ts","../../../../../../../libs/components/src/lib/data-filter/toolbar/filter-toolbar.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ViewChild, ViewEncapsulation } from '@angular/core';\nimport { AXHtmlUtil, AXMenuItem } from '@acorex/core';\nimport { AXFilterPanelComponent } from '../filter-panel/filter-panel.component';\nimport { AXToolbarItem } from '../../toolbar/toolbar-item';\nimport { AXToolbarMenuComponent } from '../../toolbar/menu/toolbar-menu.component';\nimport { AXMenuComponent } from '../../menu/menu.component';\n\n\n@Component({\n    selector: 'ax-toolbar-filter-view',\n    templateUrl: './filter-toolbar.component.html',\n    styleUrls: ['./filter-toolbar.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    providers: [{ provide: AXToolbarItem, useExisting: AXToolbarFilterViewComponent }]\n})\nexport class AXToolbarFilterViewComponent {\n    constructor() { }\n    _uid: string = AXHtmlUtil.getUID();\n\n    @ViewChild('menu', { static: true }) menu: AXToolbarMenuComponent;\n    @ViewChild('contextMenu', { static: true }) contextMenu: AXMenuComponent;\n\n    @Input()\n    filterPanel: AXFilterPanelComponent;\n\n    contextMenuItems: AXMenuItem[] = [\n        // {\n        //     name: 'addFolder',\n        //     startIcon: 'fas fa-folder',\n        //     text: 'New Folder',\n        // },\n        {\n            name: 'remove',\n            startIcon: 'fas fa-trash',\n            text: 'Delete',\n        },\n    ];\n\n\n\n    menuItems: AXMenuItem[] = [\n        {\n            name: 'root',\n            startIcon: 'fas fa-filter',\n            text: 'Select All',\n            items: [\n                {\n                    name: 'selectAll',\n                    style: 'f',\n                    text: 'Select All',\n                },\n                // {\n                //     split: true,\n                //     name: 'addFolder',\n                //     startIcon: 'fas fa-folder',\n                //     text: 'New Folder',\n                // },\n                {\n                    divider: true,\n                    name: 'save',\n                    startIcon: 'fas fa-save',\n                    text: 'Save'\n                },\n                {\n                    divider: true,\n                    name: 'saveAs',\n                    startIcon: 'fas fa-save',\n                    text: 'Save As...'\n                }\n            ]\n        }\n\n    ];\n\n    ngAfterViewInit(): void {\n        setTimeout(() => {\n            this.selectAll();\n            this.addPredefinedList();\n        }, 100);\n    }\n\n    addPredefinedList() {\n        this.filterPanel.predefinedFilters.forEach(c => {\n            const item = {\n                name: c.name,\n                text: c.title,\n                type: 'f',\n                startIcon: 'fas',\n                data: c.value,\n                style: this._uid,\n                uid: AXHtmlUtil.getUID()\n            };\n            this.root.items.splice(1, 0, item);\n        });\n        this.update();\n    }\n\n    public selectAll(): void {\n        this.setCurrent(this.root.items[0]);\n        this.filterPanel.clear();\n        this.update();\n        this.menu.close();\n        // this.contextMenu.close();\n    }\n\n    itemClick(e: AXMenuItem) {\n\n        if (e.style === 'f') {\n            if (e.name === 'selectAll') {\n                this.selectAll();\n            }\n            else {\n                this.setCurrent(e);\n                this.filterPanel.load(e.data);\n            }\n        }\n        else {\n            if (e.name === 'saveAs') {\n                const name = prompt('Please enter the name;');\n                if (name) {\n                    const item = {\n                        text: name,\n                        type: 'f',\n                        style: this._uid,\n                        startIcon: 'fas',\n                        data: this.filterPanel.value,\n                        uid: AXHtmlUtil.getUID()\n                    };\n                    this.root.items.splice(1, 0, item);\n                    this.setCurrent(item);\n                }\n\n            }\n            if (e.name === 'save') {\n                const selected = this.findSelected();\n                if (selected) {\n                    selected.data = this.filterPanel.value;\n                }\n            }\n        }\n        this.update();\n    }\n\n    private findSelected(): AXMenuItem {\n        return this.root.items.find(c => c.selected);\n    }\n\n    private get root(): AXMenuItem {\n        return this.menuItems[0];\n    }\n\n    public update(): void {\n        this.menu.update();\n        setTimeout(() => {\n            // this.contextMenu.update();\n        }, 100);\n\n    }\n\n    private setCurrent(e: AXMenuItem) {\n        this.root.text = e.text;\n        this.root.items.filter(c => c.style === 'f').forEach(c => {\n            c.selected = false;\n            c.startIcon = 'fas';\n        });\n        e.selected = true;\n        e.startIcon = 'fas fa-check';\n        this.root.items.find(c => c.name === 'save').visible = e.name !== 'selectAll';\n    }\n\n    onCtxClick(e: AXMenuItem) {\n        const target = this.contextMenu.currentTarget as HTMLElement;\n        const menuId = target.getAttribute('data-uid');\n        if (e.name === 'remove' && menuId) {\n            this.root.items = this.root.items.filter(c => c.uid !== menuId);\n            this.selectAll();\n        }\n    }\n}\n","<ax-toolbar-menu [items]=\"menuItems\" (onItemClick)=\"itemClick($event)\" #menu >\n   \n</ax-toolbar-menu>\n<ax-menu target=\".{{_uid}}\" [items]=\"contextMenuItems\"  direction=\"vertical\"  #contextMenu (onItemClick)=\"onCtxClick($event)\">\n</ax-menu>"]}

package/esm2022/lib/data-list/core/data-list.component.mjs

@@ -0,0 +1,37 @@
+import { Input, Directive } from '@angular/core';
+import { AXBaseComponent } from '../../base/element.class';
+import * as i0 from "@angular/core";
+export class AXDataListComponent extends AXBaseComponent {
+    items = [];
+    // ngAfterContentInit(): void {
+    //   this.configDataList();
+    // }
+    configDataList() {
+        if (this.dataSource) {
+            this.dataSource.onDataReceived.subscribe(c => {
+                this.dataReceived(c.data.result);
+            });
+        }
+    }
+    dataReceived(data) {
+        this.items = data;
+    }
+    params = {};
+    fetch(params = {}) {
+        this.params = params;
+        if (this.dataSource) {
+            this.dataSource.fetch(params);
+        }
+    }
+    refresh() {
+        this.fetch(this.params);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXDataListComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: AXDataListComponent, inputs: { items: "items" }, usesInheritance: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXDataListComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { items: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/data-list/list/list.component.mjs

@@ -0,0 +1,134 @@
+import { Component, ContentChild, TemplateRef, Input, Output, EventEmitter } from "@angular/core";
+import { AXDataListComponent } from "../core/data-list.component";
+import { AXToolbarListViewComponent } from "./toolbar-list-view.component";
+import { ViewEncapsulation } from "@angular/core";
+import { AXToolbarSearchComponent } from '../../toolbar/search/toolbar-search.component';
+import { AXToolbarComponent } from '../../toolbar/toolbar.component';
+import { AXDataSourceComponent } from '../../data-source/datasource.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/cdk/drag-drop";
+export class AXListComponent extends AXDataListComponent {
+    constructor() {
+        super();
+    }
+    width = "";
+    height = "auto";
+    dropId;
+    connectedList = [];
+    allowMoveItem = false;
+    _contentDataSource;
+    _dataSource;
+    get dataSource() {
+        return this._dataSource ? this._dataSource : this._contentDataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+    }
+    _contentItemTemplate;
+    _itemTemplate;
+    get itemTemplate() {
+        return this._itemTemplate ? this._itemTemplate : this._contentItemTemplate;
+    }
+    set itemTemplate(v) {
+        this._itemTemplate = v;
+    }
+    _contentEmptyTemplate;
+    _emptyTemplate;
+    get emptyTemplate() {
+        return this._emptyTemplate ? this._emptyTemplate : this._contentEmptyTemplate;
+    }
+    set emptyTemplate(v) {
+        this._emptyTemplate = v;
+    }
+    searchToolbar;
+    viewToolbar;
+    toolbar;
+    onDirectionChanged = new EventEmitter();
+    _direction = "vertical";
+    get direction() {
+        return this._direction;
+    }
+    set direction(v) {
+        if (this._direction != v) {
+            const old = this._direction;
+            this._direction = v;
+            this.setDirection(v);
+            this.onDirectionChanged.emit({
+                component: this,
+                value: v,
+                oldValue: old
+            });
+        }
+    }
+    ngAfterViewInit() {
+        this.fetch();
+        if (this.viewToolbar) {
+            this.viewToolbar.onDirectionChanged.subscribe(c => {
+                this.direction = c.value;
+            });
+        }
+    }
+    setDirection(e) {
+        this.direction = e;
+    }
+    // dragDrop(event: CdkDragDrop<any[]>) {
+    //   if (event.previousContainer === event.container) {
+    //     moveItemInArray(event.container.data, event.previousIndex, event.currentIndex);
+    //   } else {
+    //     transferArrayItem(event.previousContainer.data,
+    //       event.container.data,
+    //       event.previousIndex,
+    //       event.currentIndex);
+    //   }
+    // }
+    dragDrop(event) {
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXListComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: AXListComponent, selector: "ax-list", inputs: { width: "width", height: "height", dropId: "dropId", connectedList: "connectedList", allowMoveItem: "allowMoveItem", dataSource: "dataSource", itemTemplate: "itemTemplate", emptyTemplate: "emptyTemplate", direction: "direction" }, outputs: { onDirectionChanged: "onDirectionChanged" }, queries: [{ propertyName: "_contentDataSource", first: true, predicate: AXDataSourceComponent, descendants: true, static: true }, { propertyName: "_contentItemTemplate", first: true, predicate: ["itemTemplate"], descendants: true, static: true }, { propertyName: "_contentEmptyTemplate", first: true, predicate: ["emptyTemplate"], descendants: true, static: true }, { propertyName: "searchToolbar", first: true, predicate: AXToolbarSearchComponent, descendants: true, static: true }, { propertyName: "viewToolbar", first: true, predicate: AXToolbarListViewComponent, descendants: true, static: true }, { propertyName: "toolbar", first: true, predicate: AXToolbarComponent, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<div [style.height]=\"height\" [style.width]=\"width\">\n  <div class=\"ax-list-toolbar\" *ngIf=\"toolbar\">\n    <ng-content select=\"ax-toolbar\"></ng-content>\n  </div>\n  <div class=\"ax-list-container\" cdkDropList [id]=\"dropId\" [cdkDropListConnectedTo]=\"connectedList\"\n    (cdkDropListDropped)=\"dragDrop($event)\" [cdkDropListData]=\"items\"\n    [ngClass]=\"{'overflow-y': direction=='vertical' || direction=='horizontal-wrap','overflow-x': direction=='horizontal' || direction=='vertical-wrap'}\">\n    <div class=\"item-wrapper\" [ngClass]=\"direction\">\n      <!-- <ng-container *ngIf=\"items && items.length; else emptyTemplate\"> -->\n      <ng-container *ngIf=\"allowMoveItem; else elseTemplate\">\n        <div class=\"ax-list-item\" *ngFor=\"let item of items\" cdkDrag [cdkDragData]=\"item\">\n          <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item,direction:direction}\">\n          </ng-container>\n          <div class=\"drop-placeholder\" *cdkDragPlaceholder></div>\n        </div>\n      </ng-container>\n      <ng-template #elseTemplate>\n        <div class=\"ax-list-item\" *ngFor=\"let item of items\">\n          <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item,direction:direction }\">\n          </ng-container>\n        </div>\n      </ng-template>\n      <!-- </ng-container> -->\n\n    </div>\n    <ng-container *ngIf=\"items==null || items.length==0\">\n      <ng-container *ngTemplateOutlet=\"emptyTemplate\">\n      </ng-container>\n    </ng-container>\n\n  </div>\n</div>", styles: [".ax-list-container{height:calc(100% - 45px);min-height:50px}.ax-list-container.overflow-x{overflow-x:auto;overflow-y:hidden}.ax-list-container.overflow-y{overflow-y:auto;overflow-x:hidden}.ax-list-container .item-wrapper{height:auto;display:flex}.ax-list-container .cdk-drop-list-dragging .cdk-drag{transition:transform .25s cubic-bezier(0,0,.2,1)}.ax-list-container .cdk-drag-animating{transition:transform .3s cubic-bezier(0,0,.2,1)}.ax-list-container .drop-placeholder{background:var(--gray-light-color);border:dotted 2px var(--border-color);min-height:60px;margin-bottom:5px;transition:transform .25s cubic-bezier(0,0,.2,1)}.ax-list-container .vertical{flex-direction:column}.ax-list-container .vertical-wrap{flex-direction:column;flex-wrap:wrap}.ax-list-container .horizontal-wrap{flex-direction:row;flex-wrap:wrap}.ax-list-container .horizontal{flex-direction:row}.ax-list-toolbar{padding:4px 5px;background:#fff;border:1px solid var(--border-color);border-radius:4px;margin-bottom:10px}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { 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: i2.CdkDropList, selector: "[cdkDropList], cdk-drop-list", inputs: ["cdkDropListConnectedTo", "cdkDropListData", "cdkDropListOrientation", "id", "cdkDropListLockAxis", "cdkDropListDisabled", "cdkDropListSortingDisabled", "cdkDropListEnterPredicate", "cdkDropListSortPredicate", "cdkDropListAutoScrollDisabled", "cdkDropListAutoScrollStep"], outputs: ["cdkDropListDropped", "cdkDropListEntered", "cdkDropListExited", "cdkDropListSorted"], exportAs: ["cdkDropList"] }, { kind: "directive", type: i2.CdkDrag, selector: "[cdkDrag]", inputs: ["cdkDragData", "cdkDragLockAxis", "cdkDragRootElement", "cdkDragBoundary", "cdkDragStartDelay", "cdkDragFreeDragPosition", "cdkDragDisabled", "cdkDragConstrainPosition", "cdkDragPreviewClass", "cdkDragPreviewContainer"], outputs: ["cdkDragStarted", "cdkDragReleased", "cdkDragEnded", "cdkDragEntered", "cdkDragExited", "cdkDragDropped", "cdkDragMoved"], exportAs: ["cdkDrag"] }, { kind: "directive", type: i2.CdkDragPlaceholder, selector: "ng-template[cdkDragPlaceholder]", inputs: ["data"] }], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXListComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "ax-list", encapsulation: ViewEncapsulation.None, template: "<div [style.height]=\"height\" [style.width]=\"width\">\n  <div class=\"ax-list-toolbar\" *ngIf=\"toolbar\">\n    <ng-content select=\"ax-toolbar\"></ng-content>\n  </div>\n  <div class=\"ax-list-container\" cdkDropList [id]=\"dropId\" [cdkDropListConnectedTo]=\"connectedList\"\n    (cdkDropListDropped)=\"dragDrop($event)\" [cdkDropListData]=\"items\"\n    [ngClass]=\"{'overflow-y': direction=='vertical' || direction=='horizontal-wrap','overflow-x': direction=='horizontal' || direction=='vertical-wrap'}\">\n    <div class=\"item-wrapper\" [ngClass]=\"direction\">\n      <!-- <ng-container *ngIf=\"items && items.length; else emptyTemplate\"> -->\n      <ng-container *ngIf=\"allowMoveItem; else elseTemplate\">\n        <div class=\"ax-list-item\" *ngFor=\"let item of items\" cdkDrag [cdkDragData]=\"item\">\n          <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item,direction:direction}\">\n          </ng-container>\n          <div class=\"drop-placeholder\" *cdkDragPlaceholder></div>\n        </div>\n      </ng-container>\n      <ng-template #elseTemplate>\n        <div class=\"ax-list-item\" *ngFor=\"let item of items\">\n          <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item,direction:direction }\">\n          </ng-container>\n        </div>\n      </ng-template>\n      <!-- </ng-container> -->\n\n    </div>\n    <ng-container *ngIf=\"items==null || items.length==0\">\n      <ng-container *ngTemplateOutlet=\"emptyTemplate\">\n      </ng-container>\n    </ng-container>\n\n  </div>\n</div>", styles: [".ax-list-container{height:calc(100% - 45px);min-height:50px}.ax-list-container.overflow-x{overflow-x:auto;overflow-y:hidden}.ax-list-container.overflow-y{overflow-y:auto;overflow-x:hidden}.ax-list-container .item-wrapper{height:auto;display:flex}.ax-list-container .cdk-drop-list-dragging .cdk-drag{transition:transform .25s cubic-bezier(0,0,.2,1)}.ax-list-container .cdk-drag-animating{transition:transform .3s cubic-bezier(0,0,.2,1)}.ax-list-container .drop-placeholder{background:var(--gray-light-color);border:dotted 2px var(--border-color);min-height:60px;margin-bottom:5px;transition:transform .25s cubic-bezier(0,0,.2,1)}.ax-list-container .vertical{flex-direction:column}.ax-list-container .vertical-wrap{flex-direction:column;flex-wrap:wrap}.ax-list-container .horizontal-wrap{flex-direction:row;flex-wrap:wrap}.ax-list-container .horizontal{flex-direction:row}.ax-list-toolbar{padding:4px 5px;background:#fff;border:1px solid var(--border-color);border-radius:4px;margin-bottom:10px}\n"] }]
+        }], ctorParameters: function () { return []; }, propDecorators: { width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], dropId: [{
+                type: Input,
+                args: ["dropId"]
+            }], connectedList: [{
+                type: Input,
+                args: ["connectedList"]
+            }], allowMoveItem: [{
+                type: Input
+            }], _contentDataSource: [{
+                type: ContentChild,
+                args: [AXDataSourceComponent, { static: true }]
+            }], dataSource: [{
+                type: Input
+            }], _contentItemTemplate: [{
+                type: ContentChild,
+                args: ['itemTemplate', { static: true }]
+            }], itemTemplate: [{
+                type: Input
+            }], _contentEmptyTemplate: [{
+                type: ContentChild,
+                args: ['emptyTemplate', { static: true }]
+            }], emptyTemplate: [{
+                type: Input
+            }], searchToolbar: [{
+                type: ContentChild,
+                args: [AXToolbarSearchComponent, { static: true }]
+            }], viewToolbar: [{
+                type: ContentChild,
+                args: [AXToolbarListViewComponent, { static: true }]
+            }], toolbar: [{
+                type: ContentChild,
+                args: [AXToolbarComponent, { static: true }]
+            }], onDirectionChanged: [{
+                type: Output
+            }], direction: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.component.js","sourceRoot":"","sources":["../../../../../../../libs/components/src/lib/data-list/list/list.component.ts","../../../../../../../libs/components/src/lib/data-list/list/list.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  ContentChild,\n  TemplateRef,\n  Input,\n  Output,\n  EventEmitter\n} from \"@angular/core\";\nimport { AXDataListComponent } from \"../core/data-list.component\";\nimport {\n  AXToolbarListViewComponent,\n  AXListViewDirection\n} from \"./toolbar-list-view.component\";\nimport { ViewEncapsulation } from \"@angular/core\";\nimport { AXToolbarSearchComponent } from '../../toolbar/search/toolbar-search.component';\nimport { AXToolbarComponent } from '../../toolbar/toolbar.component';\nimport { AXEvent, AXValueEvent } from '../../base/events.class';\nimport { AXDataSourceComponent } from '../../data-source/datasource.component';\n\n\n\n\n\n\n@Component({\n  selector: \"ax-list\",\n  templateUrl: \"./list.component.html\",\n  styleUrls: [\"./list.component.scss\"],\n  encapsulation: ViewEncapsulation.None\n})\nexport class AXListComponent extends AXDataListComponent {\n  constructor() {\n    super();\n  }\n  @Input() width: string = \"\";\n  @Input() height: string = \"auto\";\n\n  @Input(\"dropId\") public dropId: string;\n  @Input(\"connectedList\") public connectedList: string[] = [];\n\n  @Input() public allowMoveItem: boolean = false;\n\n\n  @ContentChild(AXDataSourceComponent, { static: true })\n  private _contentDataSource: AXDataSourceComponent;\n\n  private _dataSource: AXDataSourceComponent;\n\n  @Input()\n  public get dataSource(): AXDataSourceComponent {\n    return this._dataSource ? this._dataSource : this._contentDataSource;\n  }\n\n  public set dataSource(v: AXDataSourceComponent) {\n    this._dataSource = v;\n  }\n\n\n  @ContentChild('itemTemplate', { static: true })\n  _contentItemTemplate: TemplateRef<any>;\n\n\n  private _itemTemplate: TemplateRef<any>;\n  @Input()\n  public get itemTemplate(): TemplateRef<any> {\n    return this._itemTemplate ? this._itemTemplate : this._contentItemTemplate;\n  }\n  public set itemTemplate(v: TemplateRef<any>) {\n    this._itemTemplate = v;\n  }\n\n\n\n\n  @ContentChild('emptyTemplate', { static: true })\n  _contentEmptyTemplate: TemplateRef<any>;\n\n  private _emptyTemplate: TemplateRef<any>;\n  @Input()\n  public get emptyTemplate(): TemplateRef<any> {\n    return this._emptyTemplate ? this._emptyTemplate : this._contentEmptyTemplate;\n  }\n  public set emptyTemplate(v: TemplateRef<any>) {\n    this._emptyTemplate = v;\n  }\n\n\n  @ContentChild(AXToolbarSearchComponent, { static: true })\n  searchToolbar: AXToolbarSearchComponent;\n\n  @ContentChild(AXToolbarListViewComponent, { static: true })\n  viewToolbar: AXToolbarListViewComponent;\n\n  @ContentChild(AXToolbarComponent, { static: true })\n  toolbar: AXToolbarComponent;\n\n\n\n  @Output()\n  onDirectionChanged: EventEmitter<AXValueEvent<AXListViewDirection>> = new EventEmitter<AXValueEvent<AXListViewDirection>>();\n\n  private _direction: AXListViewDirection = \"vertical\";\n  @Input()\n  public get direction(): AXListViewDirection {\n    return this._direction;\n  }\n  public set direction(v: AXListViewDirection) {\n    if (this._direction != v) {\n      const old = this._direction;\n      this._direction = v;\n      this.setDirection(v);\n      this.onDirectionChanged.emit({\n        component: this,\n        value: v,\n        oldValue: old\n      });\n    }\n  }\n\n\n  ngAfterViewInit(): void {\n    this.fetch();\n    if (this.viewToolbar) {\n      this.viewToolbar.onDirectionChanged.subscribe(c => {\n        this.direction = c.value;\n      });\n    }\n  }\n\n  private setDirection(e: AXListViewDirection) {\n    this.direction = e;\n  }\n\n\n\n  // dragDrop(event: CdkDragDrop<any[]>) {\n  //   if (event.previousContainer === event.container) {\n  //     moveItemInArray(event.container.data, event.previousIndex, event.currentIndex);\n  //   } else {\n  //     transferArrayItem(event.previousContainer.data,\n  //       event.container.data,\n  //       event.previousIndex,\n  //       event.currentIndex);\n  //   }\n  // }\n  dragDrop(event: any) {\n\n  }\n}\n","<div [style.height]=\"height\" [style.width]=\"width\">\n  <div class=\"ax-list-toolbar\" *ngIf=\"toolbar\">\n    <ng-content select=\"ax-toolbar\"></ng-content>\n  </div>\n  <div class=\"ax-list-container\" cdkDropList [id]=\"dropId\" [cdkDropListConnectedTo]=\"connectedList\"\n    (cdkDropListDropped)=\"dragDrop($event)\" [cdkDropListData]=\"items\"\n    [ngClass]=\"{'overflow-y': direction=='vertical' || direction=='horizontal-wrap','overflow-x': direction=='horizontal' || direction=='vertical-wrap'}\">\n    <div class=\"item-wrapper\" [ngClass]=\"direction\">\n      <!-- <ng-container *ngIf=\"items && items.length; else emptyTemplate\"> -->\n      <ng-container *ngIf=\"allowMoveItem; else elseTemplate\">\n        <div class=\"ax-list-item\" *ngFor=\"let item of items\" cdkDrag [cdkDragData]=\"item\">\n          <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item,direction:direction}\">\n          </ng-container>\n          <div class=\"drop-placeholder\" *cdkDragPlaceholder></div>\n        </div>\n      </ng-container>\n      <ng-template #elseTemplate>\n        <div class=\"ax-list-item\" *ngFor=\"let item of items\">\n          <ng-container *ngTemplateOutlet=\"itemTemplate; context: { $implicit: item,direction:direction }\">\n          </ng-container>\n        </div>\n      </ng-template>\n      <!-- </ng-container> -->\n\n    </div>\n    <ng-container *ngIf=\"items==null || items.length==0\">\n      <ng-container *ngTemplateOutlet=\"emptyTemplate\">\n      </ng-container>\n    </ng-container>\n\n  </div>\n</div>"]}

package/esm2022/lib/data-list/list/list.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { AXListComponent } from './list.component';
+import { CommonModule } from '@angular/common';
+import { AXToolbarListViewComponent } from './toolbar-list-view.component';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { AXDataSourceModule } from '../../data-source/datasource.module';
+import * as i0 from "@angular/core";
+export class AXListModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXListModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: AXListModule, declarations: [AXListComponent, AXToolbarListViewComponent], imports: [CommonModule, AXDataSourceModule, DragDropModule], exports: [AXListComponent, AXToolbarListViewComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXListModule, imports: [CommonModule, AXDataSourceModule, DragDropModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: AXListModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [AXListComponent, AXToolbarListViewComponent],
+                    imports: [CommonModule, AXDataSourceModule, DragDropModule],
+                    exports: [AXListComponent, AXToolbarListViewComponent],
+                    providers: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvc3JjL2xpYi9kYXRhLWxpc3QvbGlzdC9saXN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNuRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDM0UsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQ3hELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFDQUFxQyxDQUFDOztBQVF6RSxNQUFNLE9BQU8sWUFBWTt3R0FBWixZQUFZO3lHQUFaLFlBQVksaUJBTE4sZUFBZSxFQUFFLDBCQUEwQixhQUNoRCxZQUFZLEVBQUUsa0JBQWtCLEVBQUUsY0FBYyxhQUNoRCxlQUFlLEVBQUUsMEJBQTBCO3lHQUc1QyxZQUFZLFlBSlgsWUFBWSxFQUFFLGtCQUFrQixFQUFFLGNBQWM7OzRGQUlqRCxZQUFZO2tCQU54QixRQUFRO21CQUFDO29CQUNOLFlBQVksRUFBRSxDQUFDLGVBQWUsRUFBRSwwQkFBMEIsQ0FBQztvQkFDM0QsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGtCQUFrQixFQUFFLGNBQWMsQ0FBQztvQkFDM0QsT0FBTyxFQUFFLENBQUMsZUFBZSxFQUFFLDBCQUEwQixDQUFDO29CQUN0RCxTQUFTLEVBQUUsRUFBRTtpQkFDaEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQVhMaXN0Q29tcG9uZW50IH0gZnJvbSAnLi9saXN0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgQVhUb29sYmFyTGlzdFZpZXdDb21wb25lbnQgfSBmcm9tICcuL3Rvb2xiYXItbGlzdC12aWV3LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBEcmFnRHJvcE1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9kcmFnLWRyb3AnO1xuaW1wb3J0IHsgQVhEYXRhU291cmNlTW9kdWxlIH0gZnJvbSAnLi4vLi4vZGF0YS1zb3VyY2UvZGF0YXNvdXJjZS5tb2R1bGUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW0FYTGlzdENvbXBvbmVudCwgQVhUb29sYmFyTGlzdFZpZXdDb21wb25lbnRdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEFYRGF0YVNvdXJjZU1vZHVsZSwgRHJhZ0Ryb3BNb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtBWExpc3RDb21wb25lbnQsIEFYVG9vbGJhckxpc3RWaWV3Q29tcG9uZW50XSxcbiAgICBwcm92aWRlcnM6IFtdLFxufSlcbmV4cG9ydCBjbGFzcyBBWExpc3RNb2R1bGUgeyB9Il19