@seniorsistemas/angular-components 17.2.20 → 17.3.1

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

@@ -0,0 +1,45 @@
+import { __decorate } from "tslib";
+import { Component, Input } from '@angular/core';
+import { KanbanEventService } from '../../kanban-event.service';
+var KanbanItemComponent = /** @class */ (function () {
+    function KanbanItemComponent(_kanbanEventService) {
+        this._kanbanEventService = _kanbanEventService;
+        this.selected = false;
+    }
+    KanbanItemComponent.prototype.onSelectedChange = function (value) {
+        if (value) {
+            this._kanbanEventService.emitSelectItemEvent(this.item);
+        }
+        else {
+            this._kanbanEventService.emitUnselectItemEvent(this.item);
+        }
+    };
+    KanbanItemComponent.ctorParameters = function () { return [
+        { 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);
+    return KanbanItemComponent;
+}());
+export { KanbanItemComponent };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,20 @@
+import { __decorate } from "tslib";
+import { Component, Input } from "@angular/core";
+var KanbanItemDraggingComponent = /** @class */ (function () {
+    function KanbanItemDraggingComponent() {
+        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);
+    return KanbanItemDraggingComponent;
+}());
+export { KanbanItemDraggingComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FuYmFuLWl0ZW0tZHJhZ2dpbmcuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMva2FuYmFuL2NvbXBvbmVudHMva2FuYmFuLWl0ZW0tZHJhZ2dpbmcva2FuYmFuLWl0ZW0tZHJhZ2dpbmcuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQU9qRDtJQUFBO1FBRVcsa0JBQWEsR0FBRyxDQUFDLENBQUM7SUFDN0IsQ0FBQztJQURHO1FBREMsS0FBSyxFQUFFO3NFQUNpQjtJQUZoQiwyQkFBMkI7UUFMdkMsU0FBUyxDQUFDO1lBQ1AsUUFBUSxFQUFFLHdCQUF3QjtZQUNsQywyZEFBb0Q7O1NBRXZELENBQUM7T0FDVywyQkFBMkIsQ0FHdkM7SUFBRCxrQ0FBQztDQUFBLEFBSEQsSUFHQztTQUhZLDJCQUEyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgSW5wdXQgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG5AQ29tcG9uZW50KHtcbiAgICBzZWxlY3RvcjogXCJzLWthbmJhbi1pdGVtLWRyYWdnaW5nXCIsXG4gICAgdGVtcGxhdGVVcmw6IFwiLi9rYW5iYW4taXRlbS1kcmFnZ2luZy5jb21wb25lbnQuaHRtbFwiLFxuICAgIHN0eWxlVXJsczogW1wiLi9rYW5iYW4taXRlbS1kcmFnZ2luZy5jb21wb25lbnQuc2Nzc1wiXSxcbn0pXG5leHBvcnQgY2xhc3MgS2FuYmFuSXRlbURyYWdnaW5nQ29tcG9uZW50IHtcbiAgICBASW5wdXQoKVxuICAgIHB1YmxpYyBxdWFudGl0eUl0ZW1zID0gMDtcbn1cbiJdfQ==

package/esm5/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/esm5/components/kanban/kanban-event.service.js

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

package/esm5/components/kanban/kanban.component.js

@@ -0,0 +1,213 @@
+import { __assign, __decorate, __read, __spread } 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';
+var KanbanComponent = /** @class */ (function () {
+    function KanbanComponent(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();
+    }
+    KanbanComponent.prototype.ngOnInit = function () {
+        this._subscribeEvents();
+        this._normalizeData();
+        this._validateInputs();
+    };
+    KanbanComponent.prototype.ngAfterContentInit = function () {
+        this._getTemplates();
+    };
+    KanbanComponent.prototype.ngOnDestroy = function () {
+        this._unsubscribe$.next();
+        this._unsubscribe$.complete();
+    };
+    KanbanComponent.prototype.drop = function (event) {
+        var _this = this;
+        var _a;
+        var previousColumn = this.data.columns.find(function (column) { return column.id === event.previousContainer.id; });
+        var targetColumn = this.data.columns.find(function (column) { return 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(function (item) {
+            var 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: __spread(this.selectedItems),
+            previousColumn: previousColumn,
+            targetColumn: targetColumn,
+        });
+        if ((_a = this.dataUpdated.observers) === null || _a === void 0 ? void 0 : _a.length) {
+            this.dataUpdated.emit(__assign({}, this.data));
+        }
+        this.data.columns.forEach(function (column) {
+            _this.kanbanEventService.emitUnselectAllColumnItemsEvent(column);
+        });
+        this.selectedItems.clear();
+    };
+    KanbanComponent.prototype.selectItem = function (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);
+        }
+    };
+    KanbanComponent.prototype.dragStarted = function () {
+        var _this = this;
+        this.selectedItems.forEach(function (item) {
+            _this.draggingItems.add(item);
+        });
+    };
+    KanbanComponent.prototype.dragReleased = function () {
+        this.draggingItems.clear();
+    };
+    KanbanComponent.prototype.getLinkedColumns = function (currentColumn) {
+        return this.data.columns
+            .filter(function (column) { return column != currentColumn; })
+            .map(function (column) { return column.id; });
+    };
+    KanbanComponent.prototype.getColumnHeaderTemplate = function () {
+        return this._getCustomTemplate(KanbanTemplateTypes.ColumnHeader);
+    };
+    KanbanComponent.prototype.getColumnEmptyMessageTemplate = function () {
+        return this._getCustomTemplate(KanbanTemplateTypes.ColumnEmptyMessage);
+    };
+    KanbanComponent.prototype.getItemHeaderTemplate = function () {
+        return this._getCustomTemplate(KanbanTemplateTypes.ItemHeader);
+    };
+    KanbanComponent.prototype.getItemBodyTemplate = function () {
+        return this._getCustomTemplate(KanbanTemplateTypes.ItemBody);
+    };
+    KanbanComponent.prototype.getItemFooterTemplate = function () {
+        return this._getCustomTemplate(KanbanTemplateTypes.ItemFooter);
+    };
+    KanbanComponent.prototype._getCustomTemplate = function (type) {
+        var _a;
+        return (_a = this.templates.find(function (template) { return template.type === type; })) === null || _a === void 0 ? void 0 : _a.template;
+    };
+    KanbanComponent.prototype._subscribeEvents = function () {
+        var _this = this;
+        this.kanbanEventService.selectAllColumnItemsEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe(function (column) {
+            column.items
+                .filter(function (item) { return !item.disabled; })
+                .forEach(function (item) {
+                _this.selectedItems.add(item);
+            });
+            _this.selectedColumn = column;
+            _this.itemsSelected.emit(__spread(_this.selectedItems));
+        });
+        this.kanbanEventService.unselectAllColumnItemsEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe(function (_) {
+            _this.selectedItems.clear();
+        });
+        this.kanbanEventService.selectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe(function (item) {
+            if (_this.selectedColumn && !_this.selectedColumn.items.includes(item)) {
+                _this.selectedItems.clear();
+            }
+            _this.selectedItems.add(item);
+            _this.itemsSelected.emit(__spread(_this.selectedItems));
+            // Finding the item column and setting selectedColumn.
+            _this.data.columns.forEach(function (column) {
+                column.items.forEach(function (currentItem) {
+                    if (currentItem === item) {
+                        _this.selectedColumn = column;
+                        return;
+                    }
+                });
+            });
+        });
+        this.kanbanEventService.unselectItemEvent
+            .pipe(takeUntil(this._unsubscribe$))
+            .subscribe(function (item) {
+            _this.selectedItems.delete(item);
+        });
+    };
+    KanbanComponent.prototype._normalizeData = function () {
+        this.data.columns.forEach(function (column) {
+            column.id = column.id || "id-" + Math.random().toString(36).substring(2, 9) + "-" + Date.now().toString(36);
+        });
+    };
+    KanbanComponent.prototype._validateInputs = function () {
+        var columns = this.data.columns;
+        var columnIds = this.data.columns.map(function (column) { return column.id; });
+        if (new Set(columnIds).size !== columns.length) {
+            throw new Error("Repeated IDs are not accepted.");
+        }
+    };
+    KanbanComponent.prototype._getTemplates = function () {
+        this.columnHeaderTemplate = this.getColumnHeaderTemplate();
+        this.columnEmptyMessageTemplate = this.getColumnEmptyMessageTemplate();
+        this.itemHeaderTemplate = this.getItemHeaderTemplate();
+        this.itemBodyTemplate = this.getItemBodyTemplate();
+        this.itemFooterTemplate = this.getItemFooterTemplate();
+    };
+    KanbanComponent.ctorParameters = function () { return [
+        { 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);
+    return 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"]}

package/esm5/components/kanban/kanban.module.js

@@ -0,0 +1,48 @@
+import { __decorate } from "tslib";
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { TieredMenuModule } from "primeng/tieredmenu";
+import { TranslateModule } from "@ngx-translate/core";
+import { BadgeModule } from "../badge/badge.module";
+import { ButtonModule } from "../button/button.module";
+import { KanbanComponent } from "./kanban.component";
+import { KanbanEventService } from "./kanban-event.service";
+import { KanbanItemComponent } from "./components/kanban-item/kanban-item.component";
+import { KanbanColumnComponent } from "./components/kanban-column/kanban-column.component";
+import { KanbanItemDraggingComponent } from "./components/kanban-item-dragging/kanban-item-dragging.component";
+import { TemplateDirective } from "./template.directive";
+var KanbanModule = /** @class */ (function () {
+    function KanbanModule() {
+    }
+    KanbanModule = __decorate([
+        NgModule({
+            imports: [
+                CommonModule,
+                FormsModule,
+                ReactiveFormsModule,
+                TranslateModule,
+                DragDropModule,
+                BadgeModule,
+                ButtonModule,
+                TieredMenuModule,
+            ],
+            declarations: [
+                KanbanComponent,
+                KanbanItemComponent,
+                KanbanColumnComponent,
+                KanbanItemDraggingComponent,
+                TemplateDirective,
+            ],
+            exports: [
+                KanbanComponent,
+                TemplateDirective,
+            ],
+            providers: [KanbanEventService],
+        })
+    ], KanbanModule);
+    return KanbanModule;
+}());
+export { KanbanModule };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/kanban/models/index.js

@@ -0,0 +1,2 @@
+export { KanbanTemplateTypes } from "./kanban-template-types";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9rYW5iYW4vbW9kZWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgS2FuYmFuRGF0YSwgS2FuYmFuQ29sdW1uLCBLYW5iYW5JdGVtLCBLYW5iYW5JdGVtTW92ZWREYXRhIH0gZnJvbSBcIi4va2FuYmFuLWRhdGFcIjtcbmV4cG9ydCB7IEthbmJhblRlbXBsYXRlVHlwZXMgfSBmcm9tIFwiLi9rYW5iYW4tdGVtcGxhdGUtdHlwZXNcIjtcbiJdfQ==

package/esm5/components/kanban/models/kanban-data.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FuYmFuLWRhdGEuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9Ac2VuaW9yc2lzdGVtYXMvYW5ndWxhci1jb21wb25lbnRzLyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9rYW5iYW4vbW9kZWxzL2thbmJhbi1kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUaWVyZWRNZW51SXRlbURhdGEgfSBmcm9tIFwiLi4vLi4vdGllcmVkLW1lbnUvbW9kZWxzL3RpZXJlZC1tZW51LWl0ZW0tZGF0YVwiO1xuXG5leHBvcnQgaW50ZXJmYWNlIEthbmJhbkRhdGEge1xuICAgIGNvbHVtbnM6IEthbmJhbkNvbHVtbltdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEthbmJhbkNvbHVtbiB7XG4gICAgaWQ/OiBzdHJpbmc7XG4gICAgdGl0bGU6IHN0cmluZztcbiAgICBpdGVtczogS2FuYmFuSXRlbVtdO1xuICAgIG9wdGlvbnM/OiBUaWVyZWRNZW51SXRlbURhdGFbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBLYW5iYW5JdGVtIHtcbiAgICBvcHRpb25zPzogVGllcmVkTWVudUl0ZW1EYXRhW107XG4gICAgZGlzYWJsZWQ/OiBib29sZWFuO1xuICAgIGRhdGE6IGFueTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBLYW5iYW5JdGVtTW92ZWREYXRhIHtcbiAgICBpdGVtczogS2FuYmFuSXRlbVtdLFxuICAgIHByZXZpb3VzQ29sdW1uOiBLYW5iYW5Db2x1bW47XG4gICAgdGFyZ2V0Q29sdW1uOiBLYW5iYW5Db2x1bW47XG59XG4iXX0=

package/esm5/components/kanban/models/kanban-template-types.js

@@ -0,0 +1,9 @@
+export var KanbanTemplateTypes;
+(function (KanbanTemplateTypes) {
+    KanbanTemplateTypes["ColumnHeader"] = "column-header";
+    KanbanTemplateTypes["ColumnEmptyMessage"] = "column-empty-message";
+    KanbanTemplateTypes["ItemHeader"] = "item-header";
+    KanbanTemplateTypes["ItemBody"] = "item-body";
+    KanbanTemplateTypes["ItemFooter"] = "item-footer";
+})(KanbanTemplateTypes || (KanbanTemplateTypes = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2FuYmFuLXRlbXBsYXRlLXR5cGVzLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMva2FuYmFuL21vZGVscy9rYW5iYW4tdGVtcGxhdGUtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksbUJBTVg7QUFORCxXQUFZLG1CQUFtQjtJQUMzQixxREFBOEIsQ0FBQTtJQUM5QixrRUFBMkMsQ0FBQTtJQUMzQyxpREFBMEIsQ0FBQTtJQUMxQiw2Q0FBc0IsQ0FBQTtJQUN0QixpREFBMEIsQ0FBQTtBQUM5QixDQUFDLEVBTlcsbUJBQW1CLEtBQW5CLG1CQUFtQixRQU05QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEthbmJhblRlbXBsYXRlVHlwZXMge1xuICAgIENvbHVtbkhlYWRlciA9IFwiY29sdW1uLWhlYWRlclwiLFxuICAgIENvbHVtbkVtcHR5TWVzc2FnZSA9IFwiY29sdW1uLWVtcHR5LW1lc3NhZ2VcIixcbiAgICBJdGVtSGVhZGVyID0gXCJpdGVtLWhlYWRlclwiLFxuICAgIEl0ZW1Cb2R5ID0gXCJpdGVtLWJvZHlcIixcbiAgICBJdGVtRm9vdGVyID0gXCJpdGVtLWZvb3RlclwiLFxufVxuIl19

package/esm5/components/kanban/template.directive.js

@@ -0,0 +1,21 @@
+import { __decorate } from "tslib";
+import { Directive, Input, TemplateRef } from "@angular/core";
+var TemplateDirective = /** @class */ (function () {
+    function TemplateDirective(template) {
+        this.template = template;
+    }
+    TemplateDirective.ctorParameters = function () { return [
+        { type: TemplateRef }
+    ]; };
+    __decorate([
+        Input("sTemplate")
+    ], TemplateDirective.prototype, "type", void 0);
+    TemplateDirective = __decorate([
+        Directive({
+            selector: "[sTemplate]",
+        })
+    ], TemplateDirective);
+    return TemplateDirective;
+}());
+export { TemplateDirective };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQHNlbmlvcnNpc3RlbWFzL2FuZ3VsYXItY29tcG9uZW50cy8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMva2FuYmFuL3RlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSzlEO0lBSUksMkJBQTRCLFFBQTBCO1FBQTFCLGFBQVEsR0FBUixRQUFRLENBQWtCO0lBQUcsQ0FBQzs7Z0JBQXBCLFdBQVc7O0lBRmpEO1FBREMsS0FBSyxDQUFDLFdBQVcsQ0FBQzttREFDQztJQUZYLGlCQUFpQjtRQUg3QixTQUFTLENBQUM7WUFDUCxRQUFRLEVBQUUsYUFBYTtTQUMxQixDQUFDO09BQ1csaUJBQWlCLENBSzdCO0lBQUQsd0JBQUM7Q0FBQSxBQUxELElBS0M7U0FMWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBUZW1wbGF0ZVJlZiB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiBcIltzVGVtcGxhdGVdXCIsXG59KVxuZXhwb3J0IGNsYXNzIFRlbXBsYXRlRGlyZWN0aXZlIHtcbiAgICBASW5wdXQoXCJzVGVtcGxhdGVcIilcbiAgICBwdWJsaWMgdHlwZTogc3RyaW5nO1xuXG4gICAgY29uc3RydWN0b3IocHVibGljIHJlYWRvbmx5IHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxhbnk+KSB7fVxufSJdfQ==

package/esm5/components/progressbar/components/progressbar-determinate/progressbar-determinate.component.js

@@ -34,7 +34,7 @@ var ProgressBarDeterminateComponent = /** @class */ (function () {
         Component({
             selector: "s-progressbar-determinate",
             template: "<div class=\"progressbar-determinate\">\n    <div class=\"progressbar-container\">\n       <div\n          class=\"progressbar-active\"\n          [ngClass]=\"{\n             'progressbar-active--blue' : activeColor === 'blue',\n             'progressbar-active--green': activeColor === 'green',\n             'progressbar-active--red': activeColor === 'red',\n             'progressbar-active--yellow': activeColor === 'yellow'\n          }\"\n          [ngStyle]=\"{ 'width': value + '%' }\">\n          {{ showValue && value ? value + '%' : '' }}\n       </div>\n    </div>\n    <div\n       *ngIf=\"targetValue\"\n       class=\"target\"\n       [ngStyle]=\"{\n          'left': targetValue <= 50 ? targetValue + '%' : 'unset',\n          'right': targetValue > 50 ? 100 - targetValue + '%' : 'unset',\n          'align-items': targetValue > 50 ? 'flex-end' : 'flex-start'\n       }\">\n       <span class=\"target-line\"></span>\n       <span class=\"target-label\">\n           {{ targetLabel || value + '%' }}\n       </span>\n    </div>\n </div>\n ",
-            styles: [".progressbar-determinate{position:relative}.progressbar-determinate .progressbar-container{background-color:#d8d8d8;border-radius:4px;height:24px;overflow:hidden;width:100%}.progressbar-determinate .progressbar-container .progressbar-active{-ms-flex-align:center;align-items:center;color:#fff;display:-ms-flexbox;display:flex;font-family:\"Open Sans\",sans-serif;font-size:14px;height:100%;-ms-flex-pack:center;justify-content:center;line-height:150%;-webkit-user-select:none;-ms-user-select:none;user-select:none;width:80%}.progressbar-determinate .progressbar-container .progressbar-active--blue{background-color:#428bca}.progressbar-determinate .progressbar-container .progressbar-active--green{background-color:#0c9348}.progressbar-determinate .progressbar-container .progressbar-active--red{background-color:#c13018}.progressbar-determinate .progressbar-container .progressbar-active--yellow{background-color:#fcbf10}.progressbar-determinate .target{-ms-flex-align:start;align-items:flex-start;bottom:-38px;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;position:absolute}.progressbar-determinate .target .target-line{background-color:#333;height:40px;margin:8px 0;width:1px}.progressbar-determinate .target .target-label{background-color:#426e78;border-radius:10px;color:#e5eaea;font-family:\"Open Sans\",sans-serif;font-size:12px;line-height:150%;padding:2px 12px}"]
+            styles: [".progressbar-determinate{position:relative}.progressbar-determinate .progressbar-container{background-color:#d8d8d8;border-radius:4px;height:24px;overflow:hidden;width:100%}.progressbar-determinate .progressbar-container .progressbar-active{-ms-flex-align:center;align-items:center;color:#fff;display:-ms-flexbox;display:flex;font-family:\"Open Sans\",sans-serif;font-size:14px;height:100%;-ms-flex-pack:center;justify-content:center;line-height:150%;-webkit-user-select:none;-ms-user-select:none;user-select:none;width:80%}.progressbar-determinate .progressbar-container .progressbar-active--blue{background-color:#428bca}.progressbar-determinate .progressbar-container .progressbar-active--green{background-color:#0c9348}.progressbar-determinate .progressbar-container .progressbar-active--red{background-color:#c13018}.progressbar-determinate .progressbar-container .progressbar-active--yellow{background-color:#fcbf10;color:#212533}.progressbar-determinate .target{-ms-flex-align:start;align-items:flex-start;bottom:-38px;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;position:absolute}.progressbar-determinate .target .target-line{background-color:#333;height:40px;margin:8px 0;width:1px}.progressbar-determinate .target .target-label{background-color:#426e78;border-radius:10px;color:#e5eaea;font-family:\"Open Sans\",sans-serif;font-size:12px;line-height:150%;padding:2px 12px}"]
         })
     ], ProgressBarDeterminateComponent);
     return ProgressBarDeterminateComponent;

package/esm5/components/slide-panel/slide-panel.component.js

@@ -12,6 +12,7 @@ var SlidePanelComponent = /** @class */ (function () {
         this.openIcon = "fas fa-chevron-right";
         this.closeIcon = "fas fa-chevron-left";
         this.cache = false;
+        this.createOpen = false;
         this.panelOpened = new EventEmitter();
         this.panelClosed = new EventEmitter();
         this.isOpen = false;
@@ -42,6 +43,9 @@ var SlidePanelComponent = /** @class */ (function () {
             _this._calculateSlideHeight();
             _this._calculateSideContentWidth();
             _this.isContentAnimationDisabled = false;
+            if (_this.createOpen) {
+                _this.isOpen = true;
+            }
         });
     };
     SlidePanelComponent.prototype.ngOnDestroy = function () {
@@ -95,6 +99,9 @@ var SlidePanelComponent = /** @class */ (function () {
     __decorate([
         Input()
     ], SlidePanelComponent.prototype, "cache", void 0);
+    __decorate([
+        Input()
+    ], SlidePanelComponent.prototype, "createOpen", void 0);
     __decorate([
         Output()
     ], SlidePanelComponent.prototype, "panelOpened", void 0);
@@ -140,4 +147,4 @@ var SlidePanelComponent = /** @class */ (function () {
     return SlidePanelComponent;
 }());
 export { SlidePanelComponent };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slide-panel.component.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/slide-panel/slide-panel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { animate, state, style, transition, trigger } from \"@angular/animations\";\nimport {\n    Component,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    Input,\n    OnInit,\n    AfterViewChecked,\n    Output,\n    ViewChild,\n    OnDestroy,\n} from \"@angular/core\";\n\nimport { SlidePanelService } from \"./slide-panel.service\";\nimport { takeUntil } from \"rxjs/operators\";\nimport { Subject } from \"rxjs\";\n\nconst SMALL_DEVICE_BREAKPOINT = 420;\n\n@Component({\n    selector: \"s-slide-panel\",\n    templateUrl: \"./slide-panel.component.html\",\n    styleUrls: [\"./slide-panel.component.scss\"],\n    animations: [\n        trigger(\"cachelessAnimation\", [\n            transition(\":enter\", [\n                style({ width: \"0\" }),\n                animate(\"200ms linear\", style({ width: \"*\" })),\n            ]),\n            transition(\":leave\", [\n                style({ width: \"*\" }),\n                animate(\"200ms linear\", style({ width: \"0\" })),\n            ]),\n        ]),\n        trigger(\"cacheAnimation\", [\n            state(\"true\", style({ width: \"*\", padding: '0 16px' })),\n            state(\"false\", style({ width: '0px', padding: '0' })),\n            transition(\"* => *\", animate(\"200ms\")),\n        ]),\n    ],\n})\nexport class SlidePanelComponent implements OnInit, AfterViewChecked, OnDestroy {\n    public static nextId = 0;\n\n    @Input()\n    public id = `slide-panel-${++SlidePanelComponent.nextId}`;\n\n    @Input()\n    public openIcon = \"fas fa-chevron-right\";\n\n    @Input()\n    public closeIcon = \"fas fa-chevron-left\";\n\n    @Input()\n    public cache = false;\n\n    @Output()\n    public panelOpened = new EventEmitter<void>();\n\n    @Output()\n    public panelClosed = new EventEmitter<void>();\n\n    @ViewChild(\"slidePanel\")\n    private _slidePanelRef: ElementRef;\n\n    @ViewChild(\"slideContent\")\n    private _slideContentRef: ElementRef;\n\n    @ViewChild(\"sideContent\")\n    private _sideContentRef: ElementRef;\n\n    public isOpen = false;\n    public isSlideOver = false;\n    public isAnimating = false;\n    public isContentAnimationDisabled = true;\n\n    public slideHeight = 0;\n    public sideContentWidth = 0\n\n    private _unsubscribe$ = new Subject<void>();\n\n    @HostListener(\"window:resize\")\n    public onResize(): void {\n        this._checkOverBehavior();\n    }\n\n    constructor(private readonly slidePanelService: SlidePanelService) { }\n\n    public ngOnInit(): void {\n        this._checkOverBehavior();\n        this.slidePanelService.createSlidePanel(this.id)\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe(() => {\n                this.isOpen = false;\n            });\n    }\n\n    public ngAfterViewChecked() {\n        // to executed at a safe time prior to control returning to the browser's event loop\n        queueMicrotask(() => {\n            this._calculateSlideHeight();\n            this._calculateSideContentWidth();\n            this.isContentAnimationDisabled = false;\n        });\n    }\n\n    public ngOnDestroy(): void {\n        this._unsubscribe$.next();\n        this._unsubscribe$.complete();\n    }\n\n    public onClickButton() {\n        if (this.isAnimating) {\n            return;\n        }\n\n        this.isOpen = !this.isOpen;\n\n        if (this.isOpen) {\n            this.panelOpened.emit();\n        } else {\n            this.panelClosed.emit();\n        }\n    }\n\n    public onContentAnimationStart() {\n        this.isAnimating = true;\n    }\n\n    public onContentAnimationDone() {\n        this.isAnimating = false;\n\n        this._calculateSideContentWidth();\n    }\n\n    private _checkOverBehavior() {\n        this.isSlideOver = window.innerWidth <= SMALL_DEVICE_BREAKPOINT;\n    }\n\n    private _calculateSlideHeight() {\n        this.slideHeight = this._sideContentRef.nativeElement.clientHeight;\n    }\n\n    private _calculateSideContentWidth() {\n        const slidePanelWidth = this._slidePanelRef.nativeElement.getBoundingClientRect().width;\n        const slideContentWidth = this._slideContentRef.nativeElement.getBoundingClientRect().width;\n\n        this.sideContentWidth = slidePanelWidth - slideContentWidth;\n    }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slide-panel.component.js","sourceRoot":"ng://@seniorsistemas/angular-components/","sources":["components/slide-panel/slide-panel.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { animate, state, style, transition, trigger } from \"@angular/animations\";\nimport {\n    Component,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    Input,\n    OnInit,\n    AfterViewChecked,\n    Output,\n    ViewChild,\n    OnDestroy,\n} from \"@angular/core\";\n\nimport { SlidePanelService } from \"./slide-panel.service\";\nimport { takeUntil } from \"rxjs/operators\";\nimport { Subject } from \"rxjs\";\n\nconst SMALL_DEVICE_BREAKPOINT = 420;\n\n@Component({\n    selector: \"s-slide-panel\",\n    templateUrl: \"./slide-panel.component.html\",\n    styleUrls: [\"./slide-panel.component.scss\"],\n    animations: [\n        trigger(\"cachelessAnimation\", [\n            transition(\":enter\", [\n                style({ width: \"0\" }),\n                animate(\"200ms linear\", style({ width: \"*\" })),\n            ]),\n            transition(\":leave\", [\n                style({ width: \"*\" }),\n                animate(\"200ms linear\", style({ width: \"0\" })),\n            ]),\n        ]),\n        trigger(\"cacheAnimation\", [\n            state(\"true\", style({ width: \"*\", padding: '0 16px' })),\n            state(\"false\", style({ width: '0px', padding: '0' })),\n            transition(\"* => *\", animate(\"200ms\")),\n        ]),\n    ],\n})\nexport class SlidePanelComponent implements OnInit, AfterViewChecked, OnDestroy {\n    public static nextId = 0;\n\n    @Input()\n    public id = `slide-panel-${++SlidePanelComponent.nextId}`;\n\n    @Input()\n    public openIcon = \"fas fa-chevron-right\";\n\n    @Input()\n    public closeIcon = \"fas fa-chevron-left\";\n\n    @Input()\n    public cache = false;\n\n    @Input()\n    public createOpen = false;\n\n    @Output()\n    public panelOpened = new EventEmitter<void>();\n\n    @Output()\n    public panelClosed = new EventEmitter<void>();\n\n    @ViewChild(\"slidePanel\")\n    private _slidePanelRef: ElementRef;\n\n    @ViewChild(\"slideContent\")\n    private _slideContentRef: ElementRef;\n\n    @ViewChild(\"sideContent\")\n    private _sideContentRef: ElementRef;\n\n    public isOpen = false;\n    public isSlideOver = false;\n    public isAnimating = false;\n    public isContentAnimationDisabled = true;\n\n    public slideHeight = 0;\n    public sideContentWidth = 0\n\n    private _unsubscribe$ = new Subject<void>();\n\n    @HostListener(\"window:resize\")\n    public onResize(): void {\n        this._checkOverBehavior();\n    }\n\n    constructor(private readonly slidePanelService: SlidePanelService) { }\n\n    public ngOnInit(): void {\n        this._checkOverBehavior();\n        this.slidePanelService.createSlidePanel(this.id)\n            .pipe(takeUntil(this._unsubscribe$))\n            .subscribe(() => {\n                this.isOpen = false;\n            });\n    }\n\n    public ngAfterViewChecked() {\n        // to executed at a safe time prior to control returning to the browser's event loop\n        queueMicrotask(() => {\n            this._calculateSlideHeight();\n            this._calculateSideContentWidth();\n            this.isContentAnimationDisabled = false;\n\n            if (this.createOpen) {\n                this.isOpen = true;\n            }\n        });\n    }\n\n    public ngOnDestroy(): void {\n        this._unsubscribe$.next();\n        this._unsubscribe$.complete();\n    }\n\n    public onClickButton() {\n        if (this.isAnimating) {\n            return;\n        }\n\n        this.isOpen = !this.isOpen;\n\n        if (this.isOpen) {\n            this.panelOpened.emit();\n        } else {\n            this.panelClosed.emit();\n        }\n    }\n\n    public onContentAnimationStart() {\n        this.isAnimating = true;\n    }\n\n    public onContentAnimationDone() {\n        this.isAnimating = false;\n\n        this._calculateSideContentWidth();\n    }\n\n    private _checkOverBehavior() {\n        this.isSlideOver = window.innerWidth <= SMALL_DEVICE_BREAKPOINT;\n    }\n\n    private _calculateSlideHeight() {\n        this.slideHeight = this._sideContentRef.nativeElement.clientHeight;\n    }\n\n    private _calculateSideContentWidth() {\n        const slidePanelWidth = this._slidePanelRef.nativeElement.getBoundingClientRect().width;\n        const slideContentWidth = this._slideContentRef.nativeElement.getBoundingClientRect().width;\n\n        this.sideContentWidth = slidePanelWidth - slideContentWidth;\n    }\n}"]}