@seniorsistemas/angular-components 17.2.20 → 17.3.1

package/components/kanban/components/kanban-column/kanban-column.component.d.ts

@@ -0,0 +1,16 @@
+import { OnDestroy, OnInit, TemplateRef } from "@angular/core";
+import { KanbanColumn } from "../../models";
+import { KanbanEventService } from "../../kanban-event.service";
+import { FormControl } from "@angular/forms";
+export declare class KanbanColumnComponent implements OnInit, OnDestroy {
+    private readonly kanbanEventService;
+    data: KanbanColumn;
+    headerTemplate: TemplateRef<any>;
+    selectionControl: FormControl;
+    private _unsubscribe$;
+    constructor(kanbanEventService: KanbanEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _subscriveEvents;
+    private _validateInputs;
+}

package/components/kanban/components/kanban-item/kanban-item.component.d.ts

@@ -0,0 +1,13 @@
+import { TemplateRef } from '@angular/core';
+import { KanbanItem } from '../../models';
+import { KanbanEventService } from '../../kanban-event.service';
+export declare class KanbanItemComponent {
+    private readonly _kanbanEventService;
+    item: KanbanItem;
+    selected: boolean;
+    headerTemplate: TemplateRef<any>;
+    bodyTemplate: TemplateRef<any>;
+    footerTemplate: TemplateRef<any>;
+    constructor(_kanbanEventService: KanbanEventService);
+    onSelectedChange(value: any): void;
+}

package/components/kanban/components/kanban-item-dragging/kanban-item-dragging.component.d.ts

@@ -0,0 +1,3 @@
+export declare class KanbanItemDraggingComponent {
+    quantityItems: number;
+}

package/components/kanban/index.d.ts

@@ -0,0 +1,4 @@
+export { KanbanComponent } from "./kanban.component";
+export { KanbanModule } from "./kanban.module";
+export { KanbanData, KanbanColumn, KanbanItem, KanbanItemMovedData, KanbanTemplateTypes } from "./models";
+export { TemplateDirective } from "./template.directive";

package/components/kanban/kanban-event.service.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "@angular/core";
+import { KanbanColumn, KanbanItem } from "./models";
+export declare class KanbanEventService {
+    selectAllColumnItemsEvent: EventEmitter<KanbanColumn>;
+    unselectAllColumnItemsEvent: EventEmitter<KanbanColumn>;
+    selectItemEvent: EventEmitter<KanbanItem>;
+    unselectItemEvent: EventEmitter<KanbanItem>;
+    emitSelectAllColumnItemsEvent(column: KanbanColumn): void;
+    emitUnselectAllColumnItemsEvent(column: KanbanColumn): void;
+    emitSelectItemEvent(item: KanbanItem): void;
+    emitUnselectItemEvent(item: KanbanItem): void;
+}

package/components/kanban/kanban.component.d.ts

@@ -0,0 +1,41 @@
+import { AfterContentInit, EventEmitter, OnDestroy, OnInit, QueryList, TemplateRef } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { KanbanColumn, KanbanData, KanbanItem, KanbanItemMovedData } from './models';
+import { TemplateDirective } from './template.directive';
+import { KanbanEventService } from './kanban-event.service';
+export declare class KanbanComponent implements OnInit, AfterContentInit, OnDestroy {
+    private readonly kanbanEventService;
+    data: KanbanData;
+    itemsMoved: EventEmitter<KanbanItemMovedData>;
+    dataUpdated: EventEmitter<KanbanData>;
+    itemsSelected: EventEmitter<KanbanItem[]>;
+    selectedColumn: KanbanColumn;
+    selectedItems: Set<KanbanItem>;
+    draggingItems: Set<KanbanItem>;
+    columnHeaderTemplate: TemplateRef<any>;
+    columnEmptyMessageTemplate: TemplateRef<any>;
+    itemHeaderTemplate: TemplateRef<any>;
+    itemBodyTemplate: TemplateRef<any>;
+    itemFooterTemplate: TemplateRef<any>;
+    private _unsubscribe$;
+    templates: QueryList<TemplateDirective>;
+    constructor(kanbanEventService: KanbanEventService);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    drop(event: CdkDragDrop<KanbanItem[]>): void;
+    selectItem(event: MouseEvent, item: KanbanItem, column: KanbanColumn): void;
+    dragStarted(): void;
+    dragReleased(): void;
+    getLinkedColumns(currentColumn: KanbanColumn): string[];
+    getColumnHeaderTemplate(): TemplateRef<any>;
+    getColumnEmptyMessageTemplate(): TemplateRef<any>;
+    getItemHeaderTemplate(): TemplateRef<any>;
+    getItemBodyTemplate(): TemplateRef<any>;
+    getItemFooterTemplate(): TemplateRef<any>;
+    private _getCustomTemplate;
+    private _subscribeEvents;
+    private _normalizeData;
+    private _validateInputs;
+    private _getTemplates;
+}

package/components/kanban/kanban.module.d.ts

@@ -0,0 +1,2 @@
+export declare class KanbanModule {
+}

package/components/kanban/models/index.d.ts

@@ -0,0 +1,2 @@
+export { KanbanData, KanbanColumn, KanbanItem, KanbanItemMovedData } from "./kanban-data";
+export { KanbanTemplateTypes } from "./kanban-template-types";

package/components/kanban/models/kanban-data.d.ts

@@ -0,0 +1,20 @@
+import { TieredMenuItemData } from "../../tiered-menu/models/tiered-menu-item-data";
+export interface KanbanData {
+    columns: KanbanColumn[];
+}
+export interface KanbanColumn {
+    id?: string;
+    title: string;
+    items: KanbanItem[];
+    options?: TieredMenuItemData[];
+}
+export interface KanbanItem {
+    options?: TieredMenuItemData[];
+    disabled?: boolean;
+    data: any;
+}
+export interface KanbanItemMovedData {
+    items: KanbanItem[];
+    previousColumn: KanbanColumn;
+    targetColumn: KanbanColumn;
+}

package/components/kanban/models/kanban-template-types.d.ts

@@ -0,0 +1,7 @@
+export declare enum KanbanTemplateTypes {
+    ColumnHeader = "column-header",
+    ColumnEmptyMessage = "column-empty-message",
+    ItemHeader = "item-header",
+    ItemBody = "item-body",
+    ItemFooter = "item-footer"
+}

package/components/kanban/template.directive.d.ts

@@ -0,0 +1,6 @@
+import { TemplateRef } from "@angular/core";
+export declare class TemplateDirective {
+    readonly template: TemplateRef<any>;
+    type: string;
+    constructor(template: TemplateRef<any>);
+}

package/components/slide-panel/slide-panel.component.d.ts

@@ -7,6 +7,7 @@ export declare class SlidePanelComponent implements OnInit, AfterViewChecked, On
     openIcon: string;
     closeIcon: string;
     cache: boolean;
+    createOpen: boolean;
     panelOpened: EventEmitter<void>;
     panelClosed: EventEmitter<void>;
     private _slidePanelRef;

package/esm2015/components/kanban/components/kanban-column/kanban-column.component.js

@@ -0,0 +1,82 @@
+import { __decorate } from "tslib";
+import { Component, Input } from "@angular/core";
+import { Subject } from "rxjs";
+import { takeUntil } from "rxjs/operators";
+import { KanbanEventService } from "../../kanban-event.service";
+import { FormControl } from "@angular/forms";
+let KanbanColumnComponent = class KanbanColumnComponent {
+    constructor(kanbanEventService) {
+        this.kanbanEventService = kanbanEventService;
+        this.selectionControl = new FormControl(false);
+        this._unsubscribe$ = new Subject();
+    }
+    ngOnInit() {
+        this._validateInputs();
+        this._subscriveEvents();
+    }
+    ngOnDestroy() {
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+    }
+    _subscriveEvents() {
+        this.selectionControl.valueChanges
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((value) => {
+            if (value) {
+                this.kanbanEventService.emitSelectAllColumnItemsEvent(this.data);
+            }
+            else {
+                this.kanbanEventService.emitUnselectAllColumnItemsEvent(this.data);
+            }
+        });
+        this.kanbanEventService.unselectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((_) => {
+            this.selectionControl.setValue(false, { emitEvent: false });
+        });
+        this.kanbanEventService.selectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (!this.data.items.includes(item)) {
+                this.selectionControl.setValue(false, { emitEvent: false });
+            }
+        });
+        this.kanbanEventService.selectAllColumnItemsEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((column) => {
+            if (this.data !== column) {
+                this.selectionControl.setValue(false, { emitEvent: false });
+            }
+        });
+        this.kanbanEventService.unselectAllColumnItemsEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((column) => {
+            if (this.data !== column) {
+                this.selectionControl.setValue(false, { emitEvent: false });
+            }
+        });
+    }
+    _validateInputs() {
+        if (!this.data) {
+            throw new Error("data parameter is required");
+        }
+    }
+};
+KanbanColumnComponent.ctorParameters = () => [
+    { type: KanbanEventService }
+];
+__decorate([
+    Input()
+], KanbanColumnComponent.prototype, "data", void 0);
+__decorate([
+    Input()
+], KanbanColumnComponent.prototype, "headerTemplate", void 0);
+KanbanColumnComponent = __decorate([
+    Component({
+        selector: "s-kanban-column",
+        template: "<div class=\"kanban-column\">\n    <div class=\"kanban-column__header\">\n        <div class=\"content\">\n            <form>\n                <input\n                    type=\"checkbox\"\n                    name=\"checkbox\"\n                    [formControl]=\"selectionControl\">\n            </form>\n\n            <ng-container *ngIf=\"!headerTemplate; then defaultHeaderTemplate else customHeaderTemplate\"></ng-container>\n            \n            <ng-template #defaultHeaderTemplate>\n                <div class=\"header\">\n                    <span class=\"title\">{{ data.title }} ({{ data.items.length }})</span>\n                </div>\n            </ng-template>\n            \n            <ng-template #customHeaderTemplate>\n                <ng-container *ngTemplateOutlet=\"headerTemplate; context: { $implicit: data }\"></ng-container>\n            </ng-template>\n        </div>\n        <s-button\n            *ngIf=\"data.options\"\n            priority=\"default\"\n            [disabled]=\"false\"\n            [auxiliary]=\"true\"\n            size=\"small\"\n            [model]=\"data.options\">\n        </s-button>\n    </div>\n    <div class=\"kanban-column__body\">\n        <ng-content></ng-content>\n    </div>\n</div>",
+        styles: [".kanban-column{-ms-flex-align:center;align-items:center;background-color:#fbfafc;border:1px solid #dedce5;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;height:100%;min-height:120px;-webkit-user-select:none;-ms-user-select:none;user-select:none;width:100%}.kanban-column .kanban-column__header{-ms-flex-align:center;align-items:center;border-bottom:1px solid #dedce5;display:-ms-flexbox;display:flex;-ms-flex-pack:justify;justify-content:space-between;padding:16px 16px 8px;width:100%}.kanban-column .kanban-column__header .content{display:-ms-flexbox;display:flex;gap:16px}.kanban-column .kanban-column__header .content .teste{display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;font-family:\"Open Sans\" sans-serif}.kanban-column .kanban-column__header .content .teste .title{font-size:14px;font-weight:800}.kanban-column .kanban-column__header .content .teste .description{font-size:12px}.kanban-column .kanban-column__body{display:-ms-flexbox;display:flex;height:100%;-ms-flex-pack:center;justify-content:center;width:100%}"]
+    })
+], KanbanColumnComponent);
+export { KanbanColumnComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/kanban/components/kanban-item/kanban-item.component.js

@@ -0,0 +1,44 @@
+import { __decorate } from "tslib";
+import { Component, Input } from '@angular/core';
+import { KanbanEventService } from '../../kanban-event.service';
+let KanbanItemComponent = class KanbanItemComponent {
+    constructor(_kanbanEventService) {
+        this._kanbanEventService = _kanbanEventService;
+        this.selected = false;
+    }
+    onSelectedChange(value) {
+        if (value) {
+            this._kanbanEventService.emitSelectItemEvent(this.item);
+        }
+        else {
+            this._kanbanEventService.emitUnselectItemEvent(this.item);
+        }
+    }
+};
+KanbanItemComponent.ctorParameters = () => [
+    { type: KanbanEventService }
+];
+__decorate([
+    Input()
+], KanbanItemComponent.prototype, "item", void 0);
+__decorate([
+    Input()
+], KanbanItemComponent.prototype, "selected", void 0);
+__decorate([
+    Input()
+], KanbanItemComponent.prototype, "headerTemplate", void 0);
+__decorate([
+    Input()
+], KanbanItemComponent.prototype, "bodyTemplate", void 0);
+__decorate([
+    Input()
+], KanbanItemComponent.prototype, "footerTemplate", void 0);
+KanbanItemComponent = __decorate([
+    Component({
+        selector: 's-kanban-item',
+        template: "<p-tieredMenu\n    #optionsMenu\n    [popup]=\"true\"\n    appendTo=\"body\"\n    [baseZIndex]=\"9999\"\n    [model]=\"item.options\">\n</p-tieredMenu>\n\n<div\n    class=\"kanban-item\"\n    [ngClass]=\"{\n        'kanban-item--selected': selected && !item.disabled,\n        'kanban-item--disabled': item.disabled\n    }\">\n    <div class=\"kanban-item__header\">\n        <div class=\"content\">\n            <form>\n                <input\n                    *ngIf=\"!item.disabled\"\n                    type=\"checkbox\"\n                    name=\"checkbox\"\n                    [(ngModel)]=\"selected\"\n                    (ngModelChange)=\"onSelectedChange($event)\"\n                    (click)=\"$event.stopPropagation()\">\n            </form>\n            <ng-container *ngTemplateOutlet=\"headerTemplate; context: { $implicit: item }\"></ng-container>\n        </div>\n        <button\n            *ngIf=\"item.options && !item.disabled\"\n            class=\"options-button\"\n            (click)=\"optionsMenu.toggle($event); $event.stopPropagation();\">\n            <i class=\"fas fa-ellipsis-v\"></i>\n        </button>\n    </div>\n    <div class=\"kanban-item__body\">\n        <ng-container *ngTemplateOutlet=\"bodyTemplate; context: { $implicit: item }\"></ng-container>\n    </div>\n    <div *ngIf=\"footerTemplate\" class=\"kanban-item__footer\">\n        <ng-container *ngTemplateOutlet=\"footerTemplate; context: { $implicit: item }\"></ng-container>     \n    </div>\n</div>",
+        styles: [".kanban-item{background-color:#fff;border-radius:4px;box-shadow:0 1px 5px 0 rgba(0,0,0,.25);cursor:pointer;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;margin:16px;min-width:260px;padding:16px;-webkit-user-select:none;-ms-user-select:none;user-select:none}.kanban-item .kanban-item__header{display:-ms-flexbox;display:flex;-ms-flex-pack:justify;justify-content:space-between}.kanban-item .kanban-item__header .content{display:-ms-flexbox;display:flex;gap:16px}.kanban-item .kanban-item__header .options-button{background-color:transparent;border:none;cursor:pointer;margin-right:-8px;padding:0 8px}.kanban-item .kanban-item__body{margin:16px 0}.kanban-item .kanban-item__footer{border-top:1px solid #dedce5;display:-ms-flexbox;display:flex;-ms-flex-pack:justify;justify-content:space-between}.kanban-item .kanban-item__footer .date-info{-ms-flex-align:center;align-items:center;color:#6e7280;display:-ms-flexbox;display:flex;font-family:\"Open Sans\" sans-serif;font-size:12px;gap:4px;line-height:150%}.kanban-item--selected{border:1px solid #428bca}.kanban-item--disabled{opacity:50%}"]
+    })
+], KanbanItemComponent);
+export { KanbanItemComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/kanban/components/kanban-item-dragging/kanban-item-dragging.component.js

@@ -0,0 +1,19 @@
+import { __decorate } from "tslib";
+import { Component, Input } from "@angular/core";
+let KanbanItemDraggingComponent = class KanbanItemDraggingComponent {
+    constructor() {
+        this.quantityItems = 0;
+    }
+};
+__decorate([
+    Input()
+], KanbanItemDraggingComponent.prototype, "quantityItems", void 0);
+KanbanItemDraggingComponent = __decorate([
+    Component({
+        selector: "s-kanban-item-dragging",
+        template: "<div\n    *ngIf=\"quantityItems\"\n    class=\"kanban-item-dragging\">\n</div>\n\n<div\n    class=\"kanban-item-dragging\"\n    [ngClass]=\"{ 'kanban-item-dragging--over': quantityItems }\">\n    <div class=\"content\">\n        <input type=\"checkbox\" checked />\n        <s-badge\n            [text]=\"'platform.angular_components.count_items_selected' | translate:{ count: quantityItems }\"\n            color=\"blue\">\n        </s-badge>\n    </div>\n</div>",
+        styles: [".kanban-item-dragging{background-color:#fff;border:1px solid #428bca;border-radius:4px;box-shadow:0 1px 5px 0 rgba(0,0,0,.25);height:52px;padding:16px;width:260px}.kanban-item-dragging .content{display:-ms-flexbox;display:flex;gap:16px}.kanban-item-dragging--over{left:12px;position:relative;top:-64px}"]
+    })
+], KanbanItemDraggingComponent);
+export { KanbanItemDraggingComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FuYmFuLWl0ZW0tZHJhZ2dpbmcuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMva2FuYmFuL2NvbXBvbmVudHMva2FuYmFuLWl0ZW0tZHJhZ2dpbmcva2FuYmFuLWl0ZW0tZHJhZ2dpbmcuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQU9qRCxJQUFhLDJCQUEyQixHQUF4QyxNQUFhLDJCQUEyQjtJQUF4QztRQUVXLGtCQUFhLEdBQUcsQ0FBQyxDQUFDO0lBQzdCLENBQUM7Q0FBQSxDQUFBO0FBREc7SUFEQyxLQUFLLEVBQUU7a0VBQ2lCO0FBRmhCLDJCQUEyQjtJQUx2QyxTQUFTLENBQUM7UUFDUCxRQUFRLEVBQUUsd0JBQXdCO1FBQ2xDLDJkQUFvRDs7S0FFdkQsQ0FBQztHQUNXLDJCQUEyQixDQUd2QztTQUhZLDJCQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogXCJzLWthbmJhbi1pdGVtLWRyYWdnaW5nXCIsXG4gICAgdGVtcGxhdGVVcmw6IFwiLi9rYW5iYW4taXRlbS1kcmFnZ2luZy5jb21wb25lbnQuaHRtbFwiLFxuICAgIHN0eWxlVXJsczogW1wiLi9rYW5iYW4taXRlbS1kcmFnZ2luZy5jb21wb25lbnQuc2Nzc1wiXSxcbn0pXG5leHBvcnQgY2xhc3MgS2FuYmFuSXRlbURyYWdnaW5nQ29tcG9uZW50IHtcbiAgICBASW5wdXQoKVxuICAgIHB1YmxpYyBxdWFudGl0eUl0ZW1zID0gMDtcbn1cbiJdfQ==

package/esm2015/components/kanban/index.js

@@ -0,0 +1,5 @@
+export { KanbanComponent } from "./kanban.component";
+export { KanbanModule } from "./kanban.module";
+export { KanbanTemplateTypes } from "./models";
+export { TemplateDirective } from "./template.directive";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9rYW5iYW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxPQUFPLEVBQTZELG1CQUFtQixFQUFFLE1BQU0sVUFBVSxDQUFDO0FBRTFHLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgS2FuYmFuQ29tcG9uZW50IH0gZnJvbSBcIi4va2FuYmFuLmNvbXBvbmVudFwiO1xuZXhwb3J0IHsgS2FuYmFuTW9kdWxlIH0gZnJvbSBcIi4va2FuYmFuLm1vZHVsZVwiO1xuXG5leHBvcnQgeyBLYW5iYW5EYXRhLCBLYW5iYW5Db2x1bW4sIEthbmJhbkl0ZW0sIEthbmJhbkl0ZW1Nb3ZlZERhdGEsIEthbmJhblRlbXBsYXRlVHlwZXMgfSBmcm9tIFwiLi9tb2RlbHNcIjtcblxuZXhwb3J0IHsgVGVtcGxhdGVEaXJlY3RpdmUgfSBmcm9tIFwiLi90ZW1wbGF0ZS5kaXJlY3RpdmVcIjtcbiJdfQ==

package/esm2015/components/kanban/kanban-event.service.js

@@ -0,0 +1,27 @@
+import { __decorate } from "tslib";
+import { EventEmitter, Injectable } from "@angular/core";
+let KanbanEventService = class KanbanEventService {
+    constructor() {
+        this.selectAllColumnItemsEvent = new EventEmitter();
+        this.unselectAllColumnItemsEvent = new EventEmitter();
+        this.selectItemEvent = new EventEmitter();
+        this.unselectItemEvent = new EventEmitter();
+    }
+    emitSelectAllColumnItemsEvent(column) {
+        this.selectAllColumnItemsEvent.emit(column);
+    }
+    emitUnselectAllColumnItemsEvent(column) {
+        this.unselectAllColumnItemsEvent.emit(column);
+    }
+    emitSelectItemEvent(item) {
+        this.selectItemEvent.emit(item);
+    }
+    emitUnselectItemEvent(item) {
+        this.unselectItemEvent.emit(item);
+    }
+};
+KanbanEventService = __decorate([
+    Injectable()
+], KanbanEventService);
+export { KanbanEventService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/kanban/kanban.component.js

@@ -0,0 +1,209 @@
+import { __decorate } from "tslib";
+import { Component, ContentChildren, EventEmitter, Input, Output } from '@angular/core';
+import { moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';
+import { KanbanTemplateTypes } from "./models/kanban-template-types";
+import { TemplateDirective } from './template.directive';
+import { KanbanEventService } from './kanban-event.service';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+let KanbanComponent = class KanbanComponent {
+    constructor(kanbanEventService) {
+        this.kanbanEventService = kanbanEventService;
+        this.itemsMoved = new EventEmitter();
+        this.dataUpdated = new EventEmitter();
+        this.itemsSelected = new EventEmitter();
+        this.selectedItems = new Set();
+        this.draggingItems = new Set();
+        this._unsubscribe$ = new Subject();
+    }
+    ngOnInit() {
+        this._subscribeEvents();
+        this._normalizeData();
+        this._validateInputs();
+    }
+    ngAfterContentInit() {
+        this._getTemplates();
+    }
+    ngOnDestroy() {
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+    }
+    drop(event) {
+        var _a;
+        const previousColumn = this.data.columns.find((column) => column.id === event.previousContainer.id);
+        const targetColumn = this.data.columns.find((column) => column.id === event.container.id);
+        if (!previousColumn || !targetColumn) {
+            throw new Error("Unable to obtain information about columns when performing drag and drop");
+        }
+        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);
+        }
+        this.selectedItems.forEach((item) => {
+            const previousIndex = event.previousContainer.data.indexOf(item);
+            if (previousIndex !== -1 && item !== event.item.data) {
+                if (event.previousContainer === event.container) {
+                    moveItemInArray(event.container.data, previousIndex, event.currentIndex);
+                }
+                else {
+                    transferArrayItem(event.previousContainer.data, event.container.data, previousIndex, event.currentIndex);
+                }
+            }
+        });
+        this.selectedItems.add(event.item.data);
+        this.itemsMoved.emit({
+            items: [...this.selectedItems],
+            previousColumn,
+            targetColumn,
+        });
+        if ((_a = this.dataUpdated.observers) === null || _a === void 0 ? void 0 : _a.length) {
+            this.dataUpdated.emit(Object.assign({}, this.data));
+        }
+        this.data.columns.forEach((column) => {
+            this.kanbanEventService.emitUnselectAllColumnItemsEvent(column);
+        });
+        this.selectedItems.clear();
+    }
+    selectItem(event, item, column) {
+        if (event.ctrlKey) {
+            if (this.selectedItems.delete(item)) {
+                this.kanbanEventService.emitUnselectItemEvent(item);
+            }
+            else {
+                if (this.selectedColumn && !this.selectedColumn.items.includes(item)) {
+                    this.selectedItems.clear();
+                }
+                this.selectedItems.add(item);
+                this.selectedColumn = column;
+                this.kanbanEventService.emitSelectItemEvent(item);
+            }
+        }
+        else {
+            this.selectedItems.clear();
+            this.selectedItems.add(item);
+            this.selectedColumn = column;
+            this.kanbanEventService.emitSelectItemEvent(item);
+        }
+    }
+    dragStarted() {
+        this.selectedItems.forEach((item) => {
+            this.draggingItems.add(item);
+        });
+    }
+    dragReleased() {
+        this.draggingItems.clear();
+    }
+    getLinkedColumns(currentColumn) {
+        return this.data.columns
+            .filter((column) => column != currentColumn)
+            .map((column) => column.id);
+    }
+    getColumnHeaderTemplate() {
+        return this._getCustomTemplate(KanbanTemplateTypes.ColumnHeader);
+    }
+    getColumnEmptyMessageTemplate() {
+        return this._getCustomTemplate(KanbanTemplateTypes.ColumnEmptyMessage);
+    }
+    getItemHeaderTemplate() {
+        return this._getCustomTemplate(KanbanTemplateTypes.ItemHeader);
+    }
+    getItemBodyTemplate() {
+        return this._getCustomTemplate(KanbanTemplateTypes.ItemBody);
+    }
+    getItemFooterTemplate() {
+        return this._getCustomTemplate(KanbanTemplateTypes.ItemFooter);
+    }
+    _getCustomTemplate(type) {
+        var _a;
+        return (_a = this.templates.find((template) => template.type === type)) === null || _a === void 0 ? void 0 : _a.template;
+    }
+    _subscribeEvents() {
+        this.kanbanEventService.selectAllColumnItemsEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((column) => {
+            column.items
+                .filter((item) => !item.disabled)
+                .forEach((item) => {
+                this.selectedItems.add(item);
+            });
+            this.selectedColumn = column;
+            this.itemsSelected.emit([...this.selectedItems]);
+        });
+        this.kanbanEventService.unselectAllColumnItemsEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((_) => {
+            this.selectedItems.clear();
+        });
+        this.kanbanEventService.selectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            if (this.selectedColumn && !this.selectedColumn.items.includes(item)) {
+                this.selectedItems.clear();
+            }
+            this.selectedItems.add(item);
+            this.itemsSelected.emit([...this.selectedItems]);
+            // Finding the item column and setting selectedColumn.
+            this.data.columns.forEach((column) => {
+                column.items.forEach((currentItem) => {
+                    if (currentItem === item) {
+                        this.selectedColumn = column;
+                        return;
+                    }
+                });
+            });
+        });
+        this.kanbanEventService.unselectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe((item) => {
+            this.selectedItems.delete(item);
+        });
+    }
+    _normalizeData() {
+        this.data.columns.forEach((column) => {
+            column.id = column.id || `id-${Math.random().toString(36).substring(2, 9)}-${Date.now().toString(36)}`;
+        });
+    }
+    _validateInputs() {
+        const columns = this.data.columns;
+        const columnIds = this.data.columns.map((column) => column.id);
+        if (new Set(columnIds).size !== columns.length) {
+            throw new Error("Repeated IDs are not accepted.");
+        }
+    }
+    _getTemplates() {
+        this.columnHeaderTemplate = this.getColumnHeaderTemplate();
+        this.columnEmptyMessageTemplate = this.getColumnEmptyMessageTemplate();
+        this.itemHeaderTemplate = this.getItemHeaderTemplate();
+        this.itemBodyTemplate = this.getItemBodyTemplate();
+        this.itemFooterTemplate = this.getItemFooterTemplate();
+    }
+};
+KanbanComponent.ctorParameters = () => [
+    { type: KanbanEventService }
+];
+__decorate([
+    Input()
+], KanbanComponent.prototype, "data", void 0);
+__decorate([
+    Output()
+], KanbanComponent.prototype, "itemsMoved", void 0);
+__decorate([
+    Output()
+], KanbanComponent.prototype, "dataUpdated", void 0);
+__decorate([
+    Output()
+], KanbanComponent.prototype, "itemsSelected", void 0);
+__decorate([
+    ContentChildren(TemplateDirective)
+], KanbanComponent.prototype, "templates", void 0);
+KanbanComponent = __decorate([
+    Component({
+        selector: 's-kanban',
+        template: "<div class=\"kanban\">\n  <s-kanban-column\n    *ngFor=\"let column of data.columns\"\n    [data]=\"column\"\n    [headerTemplate]=\"columnHeaderTemplate\">\n    <div\n      [id]=\"column.id\"\n      style=\"height: 100%; width: 100%;\"\n      cdkDropList\n      #dynamicList=\"cdkDropList\"\n      [cdkDropListData]=\"column.items\"\n      [cdkDropListConnectedTo]=\"getLinkedColumns(column)\"\n      (cdkDropListDropped)=\"drop($event)\">\n\n      <ng-container *ngIf=\"!columnEmptyMessageTemplate; then defaultEmptyMessageTemplate else customEmptyMessageTemplate\"></ng-container>\n\n      <ng-template #defaultEmptyMessageTemplate>\n        <div *ngIf=\"!column.items.length\" class=\"empty-message\">\n          <p class=\"text\">\n            <span class=\"fas fa-clock\"></span>&nbsp;\n            <span>{{ \"platform.angular_components.count_items_in_target\" | translate:{ count: column.items.length, target: column.title } }}</span>\n          </p>\n        </div>\n      </ng-template>\n\n      <ng-template #customEmptyMessageTemplate>\n        <ng-container *ngTemplateOutlet=\"columnEmptyMessageTemplate; context: { $implicit: column }\"></ng-container>\n      </ng-template>\n\n      <div\n        *ngFor=\"let item of column.items\"\n        cdkDrag\n        [cdkDragData]=\"item\"\n        [cdkDragDisabled]=\"item.disabled\"\n        (cdkDragStarted)=\"dragStarted()\"\n        (cdkDragReleased)=\"dragReleased()\"\n        (click)=\"selectItem($event, item, column)\">\n        \n        <ng-container *ngTemplateOutlet=\"itemTemplate\"></ng-container>\n\n        <ng-container *cdkDragPreview>\n          <ng-container *ngIf=\"selectedItems.size > 1; then itemDraggingTemplate else itemTemplate\"></ng-container>\n        </ng-container>\n\n        <ng-template #itemTemplate>\n          <s-kanban-item\n              [item]=\"item\"\n              [selected]=\"selectedItems.has(item)\"\n              [headerTemplate]=\"itemHeaderTemplate\"\n              [bodyTemplate]=\"itemBodyTemplate\"\n              [footerTemplate]=\"itemFooterTemplate\">\n            </s-kanban-item>\n        </ng-template>\n\n        <ng-template #itemDraggingTemplate>\n          <s-kanban-item-dragging [quantityItems]=\"selectedItems.size\"></s-kanban-item-dragging>\n        </ng-template>\n\n        <div *cdkDragPlaceholder>\n          <div class=\"placeholder\">\n            <div class=\"placeholder-line\"></div>\n          </div>\n        </div>\n      </div>\n    </div>\n  </s-kanban-column>\n</div>\n\n",
+        styles: [".kanban{display:-ms-flexbox;display:flex;gap:16px;width:100%}.kanban .empty-message{display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center;margin:16px}.kanban .empty-message .text{overflow:hidden;text-align:center;text-overflow:ellipsis;width:100%;white-space:nowrap}@media screen and (max-width:600px){.kanban{-ms-flex-direction:column;flex-direction:column}}s-kanban-column{display:-ms-flexbox;display:flex;-ms-flex-positive:1;flex-grow:1;min-width:292px}.placeholder{display:-ms-flexbox;display:flex;-ms-flex-pack:center;justify-content:center}.placeholder .placeholder-line{background-color:#a5a5b2;height:1px;margin:6px 0;width:50%}"]
+    })
+], KanbanComponent);
+export { KanbanComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kanban.component.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/kanban/kanban.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, OnDestroy, OnInit, Output, QueryList, TemplateRef } from '@angular/core';\nimport { CdkDragDrop, moveItemInArray, transferArrayItem } from '@angular/cdk/drag-drop';\n\nimport { KanbanColumn, KanbanData, KanbanItem, KanbanItemMovedData } from './models';\nimport { KanbanTemplateTypes } from \"./models/kanban-template-types\";\nimport { TemplateDirective } from './template.directive';\nimport { KanbanEventService } from './kanban-event.service';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\n@Component({\n    selector: 's-kanban',\n    templateUrl: './kanban.component.html',\n    styleUrls: ['./kanban.component.scss'],\n})\nexport class KanbanComponent implements OnInit, AfterContentInit, OnDestroy {\n    @Input()\n    public data: KanbanData;\n\n    @Output()\n    public itemsMoved = new EventEmitter<KanbanItemMovedData>();\n\n    @Output()\n    public dataUpdated = new EventEmitter<KanbanData>();\n\n    @Output()\n    public itemsSelected = new EventEmitter<KanbanItem[]>();\n\n    public selectedColumn: KanbanColumn;\n    public selectedItems = new Set<KanbanItem>();\n    public draggingItems = new Set<KanbanItem>();\n\n    public columnHeaderTemplate: TemplateRef<any>;\n    public columnEmptyMessageTemplate: TemplateRef<any>;\n    public itemHeaderTemplate: TemplateRef<any>;\n    public itemBodyTemplate: TemplateRef<any>;\n    public itemFooterTemplate: TemplateRef<any>;\n\n    private _unsubscribe$ = new Subject<void>();\n\n    @ContentChildren(TemplateDirective) templates: QueryList<TemplateDirective>;\n\n    constructor(\n        private readonly kanbanEventService: KanbanEventService,\n    ) { }\n\n    public ngOnInit(): void {\n        this._subscribeEvents();\n        this._normalizeData();\n        this._validateInputs();\n    }\n\n    ngAfterContentInit() {\n        this._getTemplates();\n    }\n\n    public ngOnDestroy(): void {\n        this._unsubscribe$.next();\n        this._unsubscribe$.complete();\n    }\n\n    public drop(event: CdkDragDrop<KanbanItem[]>): void {\n        const previousColumn = this.data.columns.find((column: KanbanColumn) => column.id === event.previousContainer.id);\n        const targetColumn = this.data.columns.find((column: KanbanColumn) => column.id === event.container.id);\n\n        if (!previousColumn || !targetColumn) {\n            throw new Error(\"Unable to obtain information about columns when performing drag and drop\");\n        }\n\n        if (event.previousContainer === event.container) {\n            moveItemInArray(\n                event.container.data,\n                event.previousIndex,\n                event.currentIndex,\n            );\n        } else {\n            transferArrayItem(\n                event.previousContainer.data,\n                event.container.data,\n                event.previousIndex,\n                event.currentIndex,\n            );\n        }\n\n        this.selectedItems.forEach((item: KanbanItem) => {\n            const previousIndex = event.previousContainer.data.indexOf(item);\n            if (previousIndex !== -1 && item !== event.item.data) {\n                if (event.previousContainer === event.container) {\n                    moveItemInArray(\n                        event.container.data,\n                        previousIndex,\n                        event.currentIndex,\n                    );\n                } else {\n                    transferArrayItem(\n                        event.previousContainer.data,\n                        event.container.data,\n                        previousIndex,\n                        event.currentIndex,\n                    );\n                }\n            }\n        });\n\n        this.selectedItems.add(event.item.data);\n\n        this.itemsMoved.emit({\n            items: [...this.selectedItems],\n            previousColumn,\n            targetColumn,\n        });\n\n        if (this.dataUpdated.observers?.length) {\n            this.dataUpdated.emit({ ...this.data });\n        }\n\n        this.data.columns.forEach((column: KanbanColumn) => {\n            this.kanbanEventService.emitUnselectAllColumnItemsEvent(column);\n        });\n        this.selectedItems.clear();\n    }\n\n    public selectItem(event: MouseEvent, item: KanbanItem, column: KanbanColumn): void {\n        if (event.ctrlKey) {\n            if (this.selectedItems.delete(item)) {\n                this.kanbanEventService.emitUnselectItemEvent(item);\n            } else {\n                if (this.selectedColumn && !this.selectedColumn.items.includes(item)) {\n                    this.selectedItems.clear();\n                }\n\n                this.selectedItems.add(item);\n                this.selectedColumn = column;\n                this.kanbanEventService.emitSelectItemEvent(item);\n            }\n        } else {\n            this.selectedItems.clear();\n            this.selectedItems.add(item);\n            this.selectedColumn = column;\n            this.kanbanEventService.emitSelectItemEvent(item);\n        }\n    }\n\n    public dragStarted(): void {\n        this.selectedItems.forEach((item: KanbanItem) => {\n            this.draggingItems.add(item);\n        });\n    }\n\n    public dragReleased(): void {\n        this.draggingItems.clear();\n    }\n\n    public getLinkedColumns(currentColumn: KanbanColumn) {\n        return this.data.columns\n            .filter((column: KanbanColumn) => column != currentColumn)\n            .map((column: KanbanColumn) => column.id);\n    }\n\n    public getColumnHeaderTemplate(): TemplateRef<any> {\n        return this._getCustomTemplate(KanbanTemplateTypes.ColumnHeader)\n    }\n\n    public getColumnEmptyMessageTemplate(): TemplateRef<any> {\n        return this._getCustomTemplate(KanbanTemplateTypes.ColumnEmptyMessage);\n    }\n\n    public getItemHeaderTemplate(): TemplateRef<any> {\n        return this._getCustomTemplate(KanbanTemplateTypes.ItemHeader);\n    }\n\n    public getItemBodyTemplate(): TemplateRef<any> {\n        return this._getCustomTemplate(KanbanTemplateTypes.ItemBody);\n    }\n\n    public getItemFooterTemplate(): TemplateRef<any> {\n        return this._getCustomTemplate(KanbanTemplateTypes.ItemFooter);\n    }\n\n    private _getCustomTemplate(type: string) {\n        return this.templates.find((template: TemplateDirective) => template.type === type)?.template;\n    }\n\n    private _subscribeEvents(): void {\n        this.kanbanEventService.selectAllColumnItemsEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((column: KanbanColumn) => {\n                column.items\n                    .filter((item: KanbanItem) => !item.disabled)\n                    .forEach((item: KanbanItem) => {\n                        this.selectedItems.add(item);\n                    });\n                this.selectedColumn = column;\n                this.itemsSelected.emit([...this.selectedItems]);\n            });\n\n        this.kanbanEventService.unselectAllColumnItemsEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((_) => {\n                this.selectedItems.clear();\n            });\n\n        this.kanbanEventService.selectItemEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: KanbanItem) => {\n                if (this.selectedColumn && !this.selectedColumn.items.includes(item)) {\n                    this.selectedItems.clear();\n                }\n                this.selectedItems.add(item);\n                this.itemsSelected.emit([...this.selectedItems]);\n\n                // Finding the item column and setting selectedColumn.\n                this.data.columns.forEach((column: KanbanColumn) => {\n                    column.items.forEach((currentItem: KanbanItem) => {\n                        if (currentItem === item) {\n                            this.selectedColumn = column;\n                            return;\n                        }\n                    });\n                });\n            });\n\n        this.kanbanEventService.unselectItemEvent\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe((item: KanbanItem) => {\n                this.selectedItems.delete(item);\n            });\n    }\n\n    private _normalizeData(): void {\n        this.data.columns.forEach((column: KanbanColumn) => {\n            column.id = column.id || `id-${Math.random().toString(36).substring(2, 9)}-${Date.now().toString(36)}`;\n        });\n    }\n\n    private _validateInputs(): void {\n        const columns = this.data.columns;\n        const columnIds = this.data.columns.map((column: KanbanColumn) => column.id);\n\n        if (new Set(columnIds).size !== columns.length) {\n            throw new Error(\"Repeated IDs are not accepted.\");\n        }\n    }\n\n    private _getTemplates(): void {\n        this.columnHeaderTemplate = this.getColumnHeaderTemplate();\n        this.columnEmptyMessageTemplate = this.getColumnEmptyMessageTemplate();\n        this.itemHeaderTemplate = this.getItemHeaderTemplate();\n        this.itemBodyTemplate = this.getItemBodyTemplate();\n        this.itemFooterTemplate = this.getItemFooterTemplate();\n    }\n}\n"]}