@schneideress/dashboardframework 13.0.0 → 17.0.2

package/esm2022/gridster/lib/gridster.component.mjs

@@ -0,0 +1,627 @@
+import { NgForOf, NgStyle } from '@angular/common';
+import { ChangeDetectorRef, Component, ElementRef, EventEmitter, Inject, Input, NgZone, Renderer2, ViewEncapsulation } from '@angular/core';
+import { debounceTime, Subject, switchMap, takeUntil, timer } from 'rxjs';
+import { GridsterCompact } from './gridsterCompact.service';
+import { GridsterConfigService } from './gridsterConfig.constant';
+import { GridType } from './gridsterConfig.interface';
+import { GridsterEmptyCell } from './gridsterEmptyCell.service';
+import { GridsterPreviewComponent } from './gridsterPreview.component';
+import { GridsterRenderer } from './gridsterRenderer.service';
+import { GridsterUtils } from './gridsterUtils.service';
+import * as i0 from "@angular/core";
+export class GridsterComponent {
+    constructor(el, renderer, cdRef, zone) {
+        this.renderer = renderer;
+        this.cdRef = cdRef;
+        this.zone = zone;
+        this.columns = 0;
+        this.rows = 0;
+        this.gridColumns = [];
+        this.gridRows = [];
+        this.previewStyle$ = new EventEmitter();
+        this.calculateLayout$ = new Subject();
+        this.resize$ = new Subject();
+        this.destroy$ = new Subject();
+        this.optionsChanged = () => {
+            this.setOptions();
+            let widgetsIndex = this.grid.length - 1;
+            let widget;
+            for (; widgetsIndex >= 0; widgetsIndex--) {
+                widget = this.grid[widgetsIndex];
+                widget.updateOptions();
+            }
+            this.calculateLayout();
+        };
+        this.onResize = () => {
+            if (this.el.clientWidth) {
+                if (this.options.setGridSize) {
+                    // reset width/height so the size is recalculated afterwards
+                    this.renderer.setStyle(this.el, 'width', '');
+                    this.renderer.setStyle(this.el, 'height', '');
+                }
+                this.setGridSize();
+                this.calculateLayout();
+            }
+        };
+        this.getNextPossiblePosition = (newItem, startingFrom = {}) => {
+            if (newItem.cols === -1) {
+                newItem.cols = this.$options.defaultItemCols;
+            }
+            if (newItem.rows === -1) {
+                newItem.rows = this.$options.defaultItemRows;
+            }
+            this.setGridDimensions();
+            let rowsIndex = startingFrom.y || 0;
+            let colsIndex;
+            for (; rowsIndex < this.rows; rowsIndex++) {
+                newItem.y = rowsIndex;
+                colsIndex = startingFrom.x || 0;
+                for (; colsIndex < this.columns; colsIndex++) {
+                    newItem.x = colsIndex;
+                    if (!this.checkCollision(newItem)) {
+                        return true;
+                    }
+                }
+            }
+            const canAddToRows = this.$options.maxRows >= this.rows + newItem.rows;
+            const canAddToColumns = this.$options.maxCols >= this.columns + newItem.cols;
+            const addToRows = this.rows <= this.columns && canAddToRows;
+            if (!addToRows && canAddToColumns) {
+                newItem.x = this.columns;
+                newItem.y = 0;
+                return true;
+            }
+            else if (canAddToRows) {
+                newItem.y = this.rows;
+                newItem.x = 0;
+                return true;
+            }
+            return false;
+        };
+        this.getFirstPossiblePosition = (item) => {
+            const tmpItem = Object.assign({}, item);
+            this.getNextPossiblePosition(tmpItem);
+            return tmpItem;
+        };
+        this.getLastPossiblePosition = (item) => {
+            let farthestItem = { y: 0, x: 0 };
+            farthestItem = this.grid.reduce((prev, curr) => {
+                const currCoords = {
+                    y: curr.$item.y + curr.$item.rows - 1,
+                    x: curr.$item.x + curr.$item.cols - 1
+                };
+                if (GridsterUtils.compareItems(prev, currCoords) === 1) {
+                    return currCoords;
+                }
+                else {
+                    return prev;
+                }
+            }, farthestItem);
+            const tmpItem = Object.assign({}, item);
+            this.getNextPossiblePosition(tmpItem, farthestItem);
+            return tmpItem;
+        };
+        this.el = el.nativeElement;
+        this.$options = JSON.parse(JSON.stringify(GridsterConfigService));
+        this.mobile = false;
+        this.curWidth = 0;
+        this.curHeight = 0;
+        this.grid = [];
+        this.curColWidth = 0;
+        this.curRowHeight = 0;
+        this.dragInProgress = false;
+        this.emptyCell = new GridsterEmptyCell(this);
+        this.compact = new GridsterCompact(this);
+        this.gridRenderer = new GridsterRenderer(this);
+    }
+    // ------ Function for swapWhileDragging option
+    // identical to checkCollision() except that here we add boundaries.
+    static checkCollisionTwoItemsForSwaping(item, item2) {
+        // if the cols or rows of the items are 1 , doesnt make any sense to set a boundary. Only if the item is bigger we set a boundary
+        const horizontalBoundaryItem1 = item.cols === 1 ? 0 : 1;
+        const horizontalBoundaryItem2 = item2.cols === 1 ? 0 : 1;
+        const verticalBoundaryItem1 = item.rows === 1 ? 0 : 1;
+        const verticalBoundaryItem2 = item2.rows === 1 ? 0 : 1;
+        return (item.x + horizontalBoundaryItem1 < item2.x + item2.cols &&
+            item.x + item.cols > item2.x + horizontalBoundaryItem2 &&
+            item.y + verticalBoundaryItem1 < item2.y + item2.rows &&
+            item.y + item.rows > item2.y + verticalBoundaryItem2);
+    }
+    checkCollisionTwoItems(item, item2) {
+        const collision = item.x < item2.x + item2.cols &&
+            item.x + item.cols > item2.x &&
+            item.y < item2.y + item2.rows &&
+            item.y + item.rows > item2.y;
+        if (!collision) {
+            return false;
+        }
+        if (!this.$options.allowMultiLayer) {
+            return true;
+        }
+        const defaultLayerIndex = this.$options.defaultLayerIndex;
+        const layerIndex = item.layerIndex === undefined ? defaultLayerIndex : item.layerIndex;
+        const layerIndex2 = item2.layerIndex === undefined ? defaultLayerIndex : item2.layerIndex;
+        return layerIndex === layerIndex2;
+    }
+    ngOnInit() {
+        if (this.options.initCallback) {
+            this.options.initCallback(this);
+        }
+        this.calculateLayout$
+            .pipe(debounceTime(0), takeUntil(this.destroy$))
+            .subscribe(() => this.calculateLayout());
+        this.resize$
+            .pipe(
+        // Cancel previously scheduled DOM timer if `calculateLayout()` has been called
+        // within this time range.
+        switchMap(() => timer(100)), takeUntil(this.destroy$))
+            .subscribe(() => this.resize());
+    }
+    ngOnChanges(changes) {
+        if (changes.options) {
+            this.setOptions();
+            this.options.api = {
+                optionsChanged: this.optionsChanged.bind(this),
+                resize: this.onResize.bind(this),
+                getNextPossiblePosition: this.getNextPossiblePosition.bind(this),
+                getFirstPossiblePosition: this.getFirstPossiblePosition.bind(this),
+                getLastPossiblePosition: this.getLastPossiblePosition.bind(this),
+                getItemComponent: (item) => this.getItemComponent(item),
+                getCurrentRowHeight: this.getCurrentRowHeight.bind(this)
+            };
+            this.columns = this.$options.minCols;
+            this.rows = this.$options.minRows + this.$options.addEmptyRowsCount;
+            this.setGridSize();
+            this.calculateLayout();
+        }
+    }
+    getCurrentRowHeight() {
+        return this.curRowHeight;
+    }
+    resize() {
+        let height;
+        let width;
+        if (this.$options.gridType === 'fit' && !this.mobile) {
+            width = this.el.offsetWidth;
+            height = this.el.offsetHeight;
+        }
+        else {
+            width = this.el.clientWidth;
+            height = this.el.clientHeight;
+        }
+        if ((width !== this.curWidth || height !== this.curHeight) &&
+            this.checkIfToResize()) {
+            this.onResize();
+        }
+    }
+    setOptions() {
+        this.$options = GridsterUtils.merge(this.$options, this.options, this.$options);
+        if (!this.$options.disableWindowResize && !this.windowResize) {
+            this.windowResize = this.renderer.listen('window', 'resize', this.onResize);
+        }
+        else if (this.$options.disableWindowResize && this.windowResize) {
+            this.windowResize();
+            this.windowResize = null;
+        }
+        this.emptyCell.updateOptions();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.previewStyle$.complete();
+        if (this.windowResize) {
+            this.windowResize();
+        }
+        if (this.options && this.options.destroyCallback) {
+            this.options.destroyCallback(this);
+        }
+        if (this.options && this.options.api) {
+            this.options.api.resize = undefined;
+            this.options.api.optionsChanged = undefined;
+            this.options.api.getNextPossiblePosition = undefined;
+            this.options.api = undefined;
+        }
+        this.emptyCell.destroy();
+        this.emptyCell = null;
+        this.compact.destroy();
+        this.compact = null;
+    }
+    checkIfToResize() {
+        const clientWidth = this.el.clientWidth;
+        const offsetWidth = this.el.offsetWidth;
+        const scrollWidth = this.el.scrollWidth;
+        const clientHeight = this.el.clientHeight;
+        const offsetHeight = this.el.offsetHeight;
+        const scrollHeight = this.el.scrollHeight;
+        const verticalScrollPresent = clientWidth < offsetWidth &&
+            scrollHeight > offsetHeight &&
+            scrollHeight - offsetHeight < offsetWidth - clientWidth;
+        const horizontalScrollPresent = clientHeight < offsetHeight &&
+            scrollWidth > offsetWidth &&
+            scrollWidth - offsetWidth < offsetHeight - clientHeight;
+        if (verticalScrollPresent) {
+            return false;
+        }
+        return !horizontalScrollPresent;
+    }
+    checkIfMobile() {
+        if (this.$options.useBodyForBreakpoint) {
+            return this.$options.mobileBreakpoint > document.body.clientWidth;
+        }
+        else {
+            return this.$options.mobileBreakpoint > this.curWidth;
+        }
+    }
+    setGridSize() {
+        const el = this.el;
+        let width;
+        let height;
+        if (this.$options.setGridSize ||
+            (this.$options.gridType === GridType.Fit && !this.mobile)) {
+            width = el.offsetWidth;
+            height = el.offsetHeight;
+        }
+        else {
+            width = el.clientWidth;
+            height = el.clientHeight;
+        }
+        this.curWidth = width;
+        this.curHeight = height;
+    }
+    setGridDimensions() {
+        this.setGridSize();
+        if (!this.mobile && this.checkIfMobile()) {
+            this.mobile = !this.mobile;
+            this.renderer.addClass(this.el, 'mobile');
+        }
+        else if (this.mobile && !this.checkIfMobile()) {
+            this.mobile = !this.mobile;
+            this.renderer.removeClass(this.el, 'mobile');
+        }
+        let rows = this.$options.minRows;
+        let columns = this.$options.minCols;
+        let widgetsIndex = this.grid.length - 1;
+        let widget;
+        for (; widgetsIndex >= 0; widgetsIndex--) {
+            widget = this.grid[widgetsIndex];
+            if (!widget.notPlaced) {
+                rows = Math.max(rows, widget.$item.y + widget.$item.rows);
+                columns = Math.max(columns, widget.$item.x + widget.$item.cols);
+            }
+        }
+        rows += this.$options.addEmptyRowsCount;
+        if (this.columns !== columns || this.rows !== rows) {
+            this.columns = columns;
+            this.rows = rows;
+            if (this.options.gridSizeChangedCallback) {
+                this.options.gridSizeChangedCallback(this);
+            }
+        }
+    }
+    calculateLayout() {
+        if (this.compact) {
+            this.compact.checkCompact();
+        }
+        this.setGridDimensions();
+        if (this.$options.outerMargin) {
+            let marginWidth = -this.$options.margin;
+            if (this.$options.outerMarginLeft !== null) {
+                marginWidth += this.$options.outerMarginLeft;
+                this.renderer.setStyle(this.el, 'padding-left', this.$options.outerMarginLeft + 'px');
+            }
+            else {
+                marginWidth += this.$options.margin;
+                this.renderer.setStyle(this.el, 'padding-left', this.$options.margin + 'px');
+            }
+            if (this.$options.outerMarginRight !== null) {
+                marginWidth += this.$options.outerMarginRight;
+                this.renderer.setStyle(this.el, 'padding-right', this.$options.outerMarginRight + 'px');
+            }
+            else {
+                marginWidth += this.$options.margin;
+                this.renderer.setStyle(this.el, 'padding-right', this.$options.margin + 'px');
+            }
+            this.curColWidth = (this.curWidth - marginWidth) / this.columns;
+            let marginHeight = -this.$options.margin;
+            if (this.$options.outerMarginTop !== null) {
+                marginHeight += this.$options.outerMarginTop;
+                this.renderer.setStyle(this.el, 'padding-top', this.$options.outerMarginTop + 'px');
+            }
+            else {
+                marginHeight += this.$options.margin;
+                this.renderer.setStyle(this.el, 'padding-top', this.$options.margin + 'px');
+            }
+            if (this.$options.outerMarginBottom !== null) {
+                marginHeight += this.$options.outerMarginBottom;
+                this.renderer.setStyle(this.el, 'padding-bottom', this.$options.outerMarginBottom + 'px');
+            }
+            else {
+                marginHeight += this.$options.margin;
+                this.renderer.setStyle(this.el, 'padding-bottom', this.$options.margin + 'px');
+            }
+            this.curRowHeight =
+                ((this.curHeight - marginHeight) / this.rows) *
+                    this.$options.rowHeightRatio;
+        }
+        else {
+            this.curColWidth = (this.curWidth + this.$options.margin) / this.columns;
+            this.curRowHeight =
+                ((this.curHeight + this.$options.margin) / this.rows) *
+                    this.$options.rowHeightRatio;
+            this.renderer.setStyle(this.el, 'padding-left', 0 + 'px');
+            this.renderer.setStyle(this.el, 'padding-right', 0 + 'px');
+            this.renderer.setStyle(this.el, 'padding-top', 0 + 'px');
+            this.renderer.setStyle(this.el, 'padding-bottom', 0 + 'px');
+        }
+        this.gridRenderer.updateGridster();
+        if (this.$options.setGridSize) {
+            this.renderer.addClass(this.el, 'gridSize');
+            if (!this.mobile) {
+                this.renderer.setStyle(this.el, 'width', this.columns * this.curColWidth + this.$options.margin + 'px');
+                this.renderer.setStyle(this.el, 'height', this.rows * this.curRowHeight + this.$options.margin + 'px');
+            }
+        }
+        else {
+            this.renderer.removeClass(this.el, 'gridSize');
+            this.renderer.setStyle(this.el, 'width', '');
+            this.renderer.setStyle(this.el, 'height', '');
+        }
+        this.updateGrid();
+        let widgetsIndex = this.grid.length - 1;
+        let widget;
+        for (; widgetsIndex >= 0; widgetsIndex--) {
+            widget = this.grid[widgetsIndex];
+            widget.setSize();
+            widget.drag.toggle();
+            widget.resize.toggle();
+        }
+        this.resize$.next();
+    }
+    updateGrid() {
+        if (this.$options.displayGrid === 'always' && !this.mobile) {
+            this.renderer.addClass(this.el, 'display-grid');
+        }
+        else if (this.$options.displayGrid === 'onDrag&Resize' &&
+            this.dragInProgress) {
+            this.renderer.addClass(this.el, 'display-grid');
+        }
+        else if (this.$options.displayGrid === 'none' ||
+            !this.dragInProgress ||
+            this.mobile) {
+            this.renderer.removeClass(this.el, 'display-grid');
+        }
+        this.setGridDimensions();
+        this.gridColumns.length = GridsterComponent.getNewArrayLength(this.columns, this.curWidth, this.curColWidth);
+        this.gridRows.length = GridsterComponent.getNewArrayLength(this.rows, this.curHeight, this.curRowHeight);
+        this.cdRef.markForCheck();
+    }
+    addItem(itemComponent) {
+        if (itemComponent.$item.cols === undefined) {
+            itemComponent.$item.cols = this.$options.defaultItemCols;
+            itemComponent.item.cols = itemComponent.$item.cols;
+            itemComponent.itemChanged();
+        }
+        if (itemComponent.$item.rows === undefined) {
+            itemComponent.$item.rows = this.$options.defaultItemRows;
+            itemComponent.item.rows = itemComponent.$item.rows;
+            itemComponent.itemChanged();
+        }
+        if (itemComponent.$item.x === -1 || itemComponent.$item.y === -1) {
+            this.autoPositionItem(itemComponent);
+        }
+        else if (this.checkCollision(itemComponent.$item)) {
+            if (!this.$options.disableWarnings) {
+                itemComponent.notPlaced = true;
+                console.warn("Can't be placed in the bounds of the dashboard, trying to auto position!/n" +
+                    JSON.stringify(itemComponent.item, ['cols', 'rows', 'x', 'y']));
+            }
+            if (!this.$options.disableAutoPositionOnConflict) {
+                this.autoPositionItem(itemComponent);
+            }
+            else {
+                itemComponent.notPlaced = true;
+            }
+        }
+        this.grid.push(itemComponent);
+        this.calculateLayout$.next();
+    }
+    removeItem(itemComponent) {
+        this.grid.splice(this.grid.indexOf(itemComponent), 1);
+        this.calculateLayout$.next();
+        if (this.options.itemRemovedCallback) {
+            this.options.itemRemovedCallback(itemComponent.item, itemComponent);
+        }
+    }
+    checkCollision(item) {
+        let collision = false;
+        if (this.options.itemValidateCallback) {
+            collision = !this.options.itemValidateCallback(item);
+        }
+        if (!collision && this.checkGridCollision(item)) {
+            collision = true;
+        }
+        if (!collision) {
+            const c = this.findItemWithItem(item);
+            if (c) {
+                collision = c;
+            }
+        }
+        return collision;
+    }
+    checkGridCollision(item) {
+        const noNegativePosition = item.y > -1 && item.x > -1;
+        const maxGridCols = item.cols + item.x <= this.$options.maxCols;
+        const maxGridRows = item.rows + item.y <= this.$options.maxRows;
+        const maxItemCols = item.maxItemCols === undefined
+            ? this.$options.maxItemCols
+            : item.maxItemCols;
+        const minItemCols = item.minItemCols === undefined
+            ? this.$options.minItemCols
+            : item.minItemCols;
+        const maxItemRows = item.maxItemRows === undefined
+            ? this.$options.maxItemRows
+            : item.maxItemRows;
+        const minItemRows = item.minItemRows === undefined
+            ? this.$options.minItemRows
+            : item.minItemRows;
+        const inColsLimits = item.cols <= maxItemCols && item.cols >= minItemCols;
+        const inRowsLimits = item.rows <= maxItemRows && item.rows >= minItemRows;
+        const minAreaLimit = item.minItemArea === undefined
+            ? this.$options.minItemArea
+            : item.minItemArea;
+        const maxAreaLimit = item.maxItemArea === undefined
+            ? this.$options.maxItemArea
+            : item.maxItemArea;
+        const area = item.cols * item.rows;
+        const inMinArea = minAreaLimit <= area;
+        const inMaxArea = maxAreaLimit >= area;
+        return !(noNegativePosition &&
+            maxGridCols &&
+            maxGridRows &&
+            inColsLimits &&
+            inRowsLimits &&
+            inMinArea &&
+            inMaxArea);
+    }
+    findItemWithItem(item) {
+        let widgetsIndex = 0;
+        let widget;
+        for (; widgetsIndex < this.grid.length; widgetsIndex++) {
+            widget = this.grid[widgetsIndex];
+            if (widget.$item !== item &&
+                this.checkCollisionTwoItems(widget.$item, item)) {
+                return widget;
+            }
+        }
+        return false;
+    }
+    findItemsWithItem(item) {
+        const a = [];
+        let widgetsIndex = 0;
+        let widget;
+        for (; widgetsIndex < this.grid.length; widgetsIndex++) {
+            widget = this.grid[widgetsIndex];
+            if (widget.$item !== item &&
+                this.checkCollisionTwoItems(widget.$item, item)) {
+                a.push(widget);
+            }
+        }
+        return a;
+    }
+    autoPositionItem(itemComponent) {
+        if (this.getNextPossiblePosition(itemComponent.$item)) {
+            itemComponent.notPlaced = false;
+            itemComponent.item.x = itemComponent.$item.x;
+            itemComponent.item.y = itemComponent.$item.y;
+            itemComponent.itemChanged();
+        }
+        else {
+            itemComponent.notPlaced = true;
+            if (!this.$options.disableWarnings) {
+                console.warn("Can't be placed in the bounds of the dashboard!/n" +
+                    JSON.stringify(itemComponent.item, ['cols', 'rows', 'x', 'y']));
+            }
+        }
+    }
+    pixelsToPositionX(x, roundingMethod, noLimit) {
+        const position = roundingMethod(x / this.curColWidth);
+        if (noLimit) {
+            return position;
+        }
+        else {
+            return Math.max(position, 0);
+        }
+    }
+    pixelsToPositionY(y, roundingMethod, noLimit) {
+        const position = roundingMethod(y / this.curRowHeight);
+        if (noLimit) {
+            return position;
+        }
+        else {
+            return Math.max(position, 0);
+        }
+    }
+    positionXToPixels(x) {
+        return x * this.curColWidth;
+    }
+    positionYToPixels(y) {
+        return y * this.curRowHeight;
+    }
+    getItemComponent(item) {
+        return this.grid.find(c => c.item === item);
+    }
+    // ------ Functions for swapWhileDragging option
+    // identical to checkCollision() except that this function calls findItemWithItemForSwaping() instead of findItemWithItem()
+    checkCollisionForSwaping(item) {
+        let collision = false;
+        if (this.options.itemValidateCallback) {
+            collision = !this.options.itemValidateCallback(item);
+        }
+        if (!collision && this.checkGridCollision(item)) {
+            collision = true;
+        }
+        if (!collision) {
+            const c = this.findItemWithItemForSwapping(item);
+            if (c) {
+                collision = c;
+            }
+        }
+        return collision;
+    }
+    // identical to findItemWithItem() except that this function calls checkCollisionTwoItemsForSwaping() instead of checkCollisionTwoItems()
+    findItemWithItemForSwapping(item) {
+        let widgetsIndex = this.grid.length - 1;
+        let widget;
+        for (; widgetsIndex > -1; widgetsIndex--) {
+            widget = this.grid[widgetsIndex];
+            if (widget.$item !== item &&
+                GridsterComponent.checkCollisionTwoItemsForSwaping(widget.$item, item)) {
+                return widget;
+            }
+        }
+        return false;
+    }
+    previewStyle(drag = false) {
+        if (this.movingItem) {
+            if (this.compact && drag) {
+                this.compact.checkCompactItem(this.movingItem);
+            }
+            this.previewStyle$.next(this.movingItem);
+        }
+        else {
+            this.previewStyle$.next(null);
+        }
+    }
+    // ------ End of functions for swapWhileDragging option
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    static getNewArrayLength(length, overallSize, size) {
+        const newLength = Math.max(length, Math.floor(overallSize / size));
+        if (newLength < 0) {
+            return 0;
+        }
+        if (Number.isFinite(newLength)) {
+            return Math.floor(newLength);
+        }
+        return 0;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: GridsterComponent, deps: [{ token: ElementRef }, { token: Renderer2 }, { token: ChangeDetectorRef }, { token: NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.1.1", type: GridsterComponent, isStandalone: true, selector: "gridster", inputs: { options: "options" }, usesOnChanges: true, ngImport: i0, template: "<div\r\n  class=\"gridster-column\"\r\n  *ngFor=\"let column of gridColumns; let i = index;\"\r\n  [ngStyle]=\"gridRenderer.getGridColumnStyle(i)\"\r\n></div>\r\n<div\r\n  class=\"gridster-row\"\r\n  *ngFor=\"let row of gridRows; let i = index;\"\r\n  [ngStyle]=\"gridRenderer.getGridRowStyle(i)\"\r\n></div>\r\n<ng-content></ng-content>\r\n<gridster-preview\r\n  [gridRenderer]=\"gridRenderer\"\r\n  [previewStyle$]=\"previewStyle$\"\r\n  class=\"gridster-preview\"\r\n></gridster-preview>\r\n", styles: ["gridster{position:relative;box-sizing:border-box;background:gray;width:100%;height:100%;-webkit-user-select:none;user-select:none;display:block}gridster.fit{overflow-x:hidden;overflow-y:hidden}gridster.scrollVertical{overflow-x:hidden;overflow-y:auto}gridster.scrollHorizontal{overflow-x:auto;overflow-y:hidden}gridster.fixed{overflow:auto}gridster.mobile{overflow-x:hidden;overflow-y:auto}gridster.mobile gridster-item{position:relative}gridster.gridSize{height:initial;width:initial}gridster.gridSize.fit{height:100%;width:100%}gridster .gridster-column,gridster .gridster-row{position:absolute;display:none;transition:.3s;box-sizing:border-box}gridster.display-grid .gridster-column,gridster.display-grid .gridster-row{display:block}gridster .gridster-column{border-left:1px solid white;border-right:1px solid white}gridster .gridster-row{border-top:1px solid white;border-bottom:1px solid white}\n"], dependencies: [{ kind: "directive", type: NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "component", type: GridsterPreviewComponent, selector: "gridster-preview", inputs: ["previewStyle$", "gridRenderer"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: GridsterComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'gridster', encapsulation: ViewEncapsulation.None, standalone: true, imports: [NgForOf, NgStyle, GridsterPreviewComponent], template: "<div\r\n  class=\"gridster-column\"\r\n  *ngFor=\"let column of gridColumns; let i = index;\"\r\n  [ngStyle]=\"gridRenderer.getGridColumnStyle(i)\"\r\n></div>\r\n<div\r\n  class=\"gridster-row\"\r\n  *ngFor=\"let row of gridRows; let i = index;\"\r\n  [ngStyle]=\"gridRenderer.getGridRowStyle(i)\"\r\n></div>\r\n<ng-content></ng-content>\r\n<gridster-preview\r\n  [gridRenderer]=\"gridRenderer\"\r\n  [previewStyle$]=\"previewStyle$\"\r\n  class=\"gridster-preview\"\r\n></gridster-preview>\r\n", styles: ["gridster{position:relative;box-sizing:border-box;background:gray;width:100%;height:100%;-webkit-user-select:none;user-select:none;display:block}gridster.fit{overflow-x:hidden;overflow-y:hidden}gridster.scrollVertical{overflow-x:hidden;overflow-y:auto}gridster.scrollHorizontal{overflow-x:auto;overflow-y:hidden}gridster.fixed{overflow:auto}gridster.mobile{overflow-x:hidden;overflow-y:auto}gridster.mobile gridster-item{position:relative}gridster.gridSize{height:initial;width:initial}gridster.gridSize.fit{height:100%;width:100%}gridster .gridster-column,gridster .gridster-row{position:absolute;display:none;transition:.3s;box-sizing:border-box}gridster.display-grid .gridster-column,gridster.display-grid .gridster-row{display:block}gridster .gridster-column{border-left:1px solid white;border-right:1px solid white}gridster .gridster-row{border-top:1px solid white;border-bottom:1px solid white}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.Renderer2, decorators: [{
+                    type: Inject,
+                    args: [Renderer2]
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Inject,
+                    args: [ChangeDetectorRef]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }], propDecorators: { options: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gridster.component.js","sourceRoot":"","sources":["../../../../../projects/ra-dashboard-framework/src/gridster/lib/gridster.component.ts","../../../../../projects/ra-dashboard-framework/src/gridster/lib/gridster.html"],"names":[],"mappings":"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","sourcesContent":["import { NgForOf, NgStyle } from '@angular/common';\r\nimport {\r\n  ChangeDetectorRef,\r\n  Component,\r\n  ElementRef,\r\n  EventEmitter,\r\n  Inject,\r\n  Input,\r\n  NgZone,\r\n  OnChanges,\r\n  OnDestroy,\r\n  OnInit,\r\n  Renderer2,\r\n  SimpleChanges,\r\n  ViewEncapsulation\r\n} from '@angular/core';\r\nimport { debounceTime, Subject, switchMap, takeUntil, timer } from 'rxjs';\r\nimport { GridsterComponentInterface } from './gridster.interface';\r\nimport { GridsterCompact } from './gridsterCompact.service';\r\n\r\nimport { GridsterConfigService } from './gridsterConfig.constant';\r\nimport { GridsterConfig, GridType } from './gridsterConfig.interface';\r\nimport { GridsterConfigS } from './gridsterConfigS.interface';\r\nimport { GridsterEmptyCell } from './gridsterEmptyCell.service';\r\nimport {\r\n  GridsterItem,\r\n  GridsterItemComponentInterface\r\n} from './gridsterItem.interface';\r\nimport { GridsterPreviewComponent } from './gridsterPreview.component';\r\nimport { GridsterRenderer } from './gridsterRenderer.service';\r\nimport { GridsterUtils } from './gridsterUtils.service';\r\n\r\n@Component({\r\n  // eslint-disable-next-line @angular-eslint/component-selector\r\n  selector: 'gridster',\r\n  templateUrl: './gridster.html',\r\n  styleUrls: ['./gridster.css'],\r\n  encapsulation: ViewEncapsulation.None,\r\n  standalone: true,\r\n  imports: [NgForOf, NgStyle, GridsterPreviewComponent]\r\n})\r\nexport class GridsterComponent\r\n  implements OnInit, OnChanges, OnDestroy, GridsterComponentInterface {\r\n  @Input() options!: GridsterConfig;\r\n  movingItem!: GridsterItem | null;\r\n  el: HTMLElement;\r\n  $options: GridsterConfigS;\r\n  mobile: boolean;\r\n  curWidth: number;\r\n  curHeight: number;\r\n  grid: GridsterItemComponentInterface[];\r\n  columns = 0;\r\n  rows = 0;\r\n  curColWidth: number;\r\n  curRowHeight: number;\r\n  gridColumns = [];\r\n  gridRows = [];\r\n  windowResize!: (() => void) | null;\r\n  dragInProgress: boolean;\r\n  emptyCell: GridsterEmptyCell;\r\n  compact: GridsterCompact;\r\n  gridRenderer: GridsterRenderer;\r\n  previewStyle$: EventEmitter<GridsterItem | null> =\r\n    new EventEmitter<GridsterItem | null>();\r\n\r\n  calculateLayout$ = new Subject<void>();\r\n\r\n  private resize$ = new Subject<void>();\r\n  private destroy$ = new Subject<void>();\r\n\r\n  constructor(\r\n    @Inject(ElementRef) el: ElementRef,\r\n    @Inject(Renderer2) public renderer: Renderer2,\r\n    @Inject(ChangeDetectorRef) public cdRef: ChangeDetectorRef,\r\n    @Inject(NgZone) public zone: NgZone\r\n  ) {\r\n    this.el = el.nativeElement;\r\n    this.$options = JSON.parse(JSON.stringify(GridsterConfigService));\r\n    this.mobile = false;\r\n    this.curWidth = 0;\r\n    this.curHeight = 0;\r\n    this.grid = [];\r\n    this.curColWidth = 0;\r\n    this.curRowHeight = 0;\r\n    this.dragInProgress = false;\r\n    this.emptyCell = new GridsterEmptyCell(this);\r\n    this.compact = new GridsterCompact(this);\r\n    this.gridRenderer = new GridsterRenderer(this);\r\n  }\r\n\r\n  // ------ Function for swapWhileDragging option\r\n\r\n  // identical to checkCollision() except that here we add boundaries.\r\n  static checkCollisionTwoItemsForSwaping(\r\n    item: GridsterItem,\r\n    item2: GridsterItem\r\n  ): boolean {\r\n    // if the cols or rows of the items are 1 , doesnt make any sense to set a boundary. Only if the item is bigger we set a boundary\r\n    const horizontalBoundaryItem1 = item.cols === 1 ? 0 : 1;\r\n    const horizontalBoundaryItem2 = item2.cols === 1 ? 0 : 1;\r\n    const verticalBoundaryItem1 = item.rows === 1 ? 0 : 1;\r\n    const verticalBoundaryItem2 = item2.rows === 1 ? 0 : 1;\r\n    return (\r\n      item.x + horizontalBoundaryItem1 < item2.x + item2.cols &&\r\n      item.x + item.cols > item2.x + horizontalBoundaryItem2 &&\r\n      item.y + verticalBoundaryItem1 < item2.y + item2.rows &&\r\n      item.y + item.rows > item2.y + verticalBoundaryItem2\r\n    );\r\n  }\r\n\r\n  checkCollisionTwoItems(item: GridsterItem, item2: GridsterItem): boolean {\r\n    const collision =\r\n      item.x < item2.x + item2.cols &&\r\n      item.x + item.cols > item2.x &&\r\n      item.y < item2.y + item2.rows &&\r\n      item.y + item.rows > item2.y;\r\n    if (!collision) {\r\n      return false;\r\n    }\r\n    if (!this.$options.allowMultiLayer) {\r\n      return true;\r\n    }\r\n    const defaultLayerIndex = this.$options.defaultLayerIndex;\r\n    const layerIndex =\r\n      item.layerIndex === undefined ? defaultLayerIndex : item.layerIndex;\r\n    const layerIndex2 =\r\n      item2.layerIndex === undefined ? defaultLayerIndex : item2.layerIndex;\r\n    return layerIndex === layerIndex2;\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    if (this.options.initCallback) {\r\n      this.options.initCallback(this);\r\n    }\r\n\r\n    this.calculateLayout$\r\n      .pipe(debounceTime(0), takeUntil(this.destroy$))\r\n      .subscribe(() => this.calculateLayout());\r\n\r\n    this.resize$\r\n      .pipe(\r\n        // Cancel previously scheduled DOM timer if `calculateLayout()` has been called\r\n        // within this time range.\r\n        switchMap(() => timer(100)),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe(() => this.resize());\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes.options) {\r\n      this.setOptions();\r\n      this.options.api = {\r\n        optionsChanged: this.optionsChanged.bind(this),\r\n        resize: this.onResize.bind(this),\r\n        getNextPossiblePosition: this.getNextPossiblePosition.bind(this),\r\n        getFirstPossiblePosition: this.getFirstPossiblePosition.bind(this),\r\n        getLastPossiblePosition: this.getLastPossiblePosition.bind(this),\r\n        getItemComponent: (item: GridsterItem) => this.getItemComponent(item),\r\n        getCurrentRowHeight: this.getCurrentRowHeight.bind(this)\r\n      };\r\n      this.columns = this.$options.minCols;\r\n      this.rows = this.$options.minRows + this.$options.addEmptyRowsCount;\r\n      this.setGridSize();\r\n      this.calculateLayout();\r\n    }\r\n  }\r\n\r\n  getCurrentRowHeight(): number {\r\n    return this.curRowHeight;\r\n  }\r\n\r\n  private resize(): void {\r\n    let height;\r\n    let width;\r\n    if (this.$options.gridType === 'fit' && !this.mobile) {\r\n      width = this.el.offsetWidth;\r\n      height = this.el.offsetHeight;\r\n    } else {\r\n      width = this.el.clientWidth;\r\n      height = this.el.clientHeight;\r\n    }\r\n    if (\r\n      (width !== this.curWidth || height !== this.curHeight) &&\r\n      this.checkIfToResize()\r\n    ) {\r\n      this.onResize();\r\n    }\r\n  }\r\n\r\n  setOptions(): void {\r\n    this.$options = GridsterUtils.merge(\r\n      this.$options,\r\n      this.options,\r\n      this.$options\r\n    );\r\n    if (!this.$options.disableWindowResize && !this.windowResize) {\r\n      this.windowResize = this.renderer.listen(\r\n        'window',\r\n        'resize',\r\n        this.onResize\r\n      );\r\n    } else if (this.$options.disableWindowResize && this.windowResize) {\r\n      this.windowResize();\r\n      this.windowResize = null;\r\n    }\r\n    this.emptyCell.updateOptions();\r\n  }\r\n\r\n  optionsChanged = (): void => {\r\n    this.setOptions();\r\n    let widgetsIndex: number = this.grid.length - 1;\r\n    let widget: GridsterItemComponentInterface;\r\n    for (; widgetsIndex >= 0; widgetsIndex--) {\r\n      widget = this.grid[widgetsIndex];\r\n      widget.updateOptions();\r\n    }\r\n    this.calculateLayout();\r\n  };\r\n\r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.previewStyle$.complete();\r\n    if (this.windowResize) {\r\n      this.windowResize();\r\n    }\r\n    if (this.options && this.options.destroyCallback) {\r\n      this.options.destroyCallback(this);\r\n    }\r\n    if (this.options && this.options.api) {\r\n      this.options.api.resize = undefined;\r\n      this.options.api.optionsChanged = undefined;\r\n      this.options.api.getNextPossiblePosition = undefined;\r\n      this.options.api = undefined;\r\n    }\r\n    this.emptyCell.destroy();\r\n    this.emptyCell = null!;\r\n    this.compact.destroy();\r\n    this.compact = null!;\r\n  }\r\n\r\n  onResize = (): void => {\r\n    if (this.el.clientWidth) {\r\n      if (this.options.setGridSize) {\r\n        // reset width/height so the size is recalculated afterwards\r\n        this.renderer.setStyle(this.el, 'width', '');\r\n        this.renderer.setStyle(this.el, 'height', '');\r\n      }\r\n      this.setGridSize();\r\n      this.calculateLayout();\r\n    }\r\n  };\r\n\r\n  checkIfToResize(): boolean {\r\n    const clientWidth = this.el.clientWidth;\r\n    const offsetWidth = this.el.offsetWidth;\r\n    const scrollWidth = this.el.scrollWidth;\r\n    const clientHeight = this.el.clientHeight;\r\n    const offsetHeight = this.el.offsetHeight;\r\n    const scrollHeight = this.el.scrollHeight;\r\n    const verticalScrollPresent =\r\n      clientWidth < offsetWidth &&\r\n      scrollHeight > offsetHeight &&\r\n      scrollHeight - offsetHeight < offsetWidth - clientWidth;\r\n    const horizontalScrollPresent =\r\n      clientHeight < offsetHeight &&\r\n      scrollWidth > offsetWidth &&\r\n      scrollWidth - offsetWidth < offsetHeight - clientHeight;\r\n    if (verticalScrollPresent) {\r\n      return false;\r\n    }\r\n    return !horizontalScrollPresent;\r\n  }\r\n\r\n  checkIfMobile(): boolean {\r\n    if (this.$options.useBodyForBreakpoint) {\r\n      return this.$options.mobileBreakpoint > document.body.clientWidth;\r\n    } else {\r\n      return this.$options.mobileBreakpoint > this.curWidth;\r\n    }\r\n  }\r\n\r\n  setGridSize(): void {\r\n    const el = this.el;\r\n    let width;\r\n    let height;\r\n    if (\r\n      this.$options.setGridSize ||\r\n      (this.$options.gridType === GridType.Fit && !this.mobile)\r\n    ) {\r\n      width = el.offsetWidth;\r\n      height = el.offsetHeight;\r\n    } else {\r\n      width = el.clientWidth;\r\n      height = el.clientHeight;\r\n    }\r\n    this.curWidth = width;\r\n    this.curHeight = height;\r\n  }\r\n\r\n  setGridDimensions(): void {\r\n    this.setGridSize();\r\n    if (!this.mobile && this.checkIfMobile()) {\r\n      this.mobile = !this.mobile;\r\n      this.renderer.addClass(this.el, 'mobile');\r\n    } else if (this.mobile && !this.checkIfMobile()) {\r\n      this.mobile = !this.mobile;\r\n      this.renderer.removeClass(this.el, 'mobile');\r\n    }\r\n    let rows = this.$options.minRows;\r\n    let columns = this.$options.minCols;\r\n\r\n    let widgetsIndex = this.grid.length - 1;\r\n    let widget;\r\n    for (; widgetsIndex >= 0; widgetsIndex--) {\r\n      widget = this.grid[widgetsIndex];\r\n      if (!widget.notPlaced) {\r\n        rows = Math.max(rows, widget.$item.y + widget.$item.rows);\r\n        columns = Math.max(columns, widget.$item.x + widget.$item.cols);\r\n      }\r\n    }\r\n    rows += this.$options.addEmptyRowsCount;\r\n    if (this.columns !== columns || this.rows !== rows) {\r\n      this.columns = columns;\r\n      this.rows = rows;\r\n      if (this.options.gridSizeChangedCallback) {\r\n        this.options.gridSizeChangedCallback(this);\r\n      }\r\n    }\r\n  }\r\n\r\n  private calculateLayout(): void {\r\n    if (this.compact) {\r\n      this.compact.checkCompact();\r\n    }\r\n\r\n    this.setGridDimensions();\r\n    if (this.$options.outerMargin) {\r\n      let marginWidth = -this.$options.margin;\r\n      if (this.$options.outerMarginLeft !== null) {\r\n        marginWidth += this.$options.outerMarginLeft;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-left',\r\n          this.$options.outerMarginLeft + 'px'\r\n        );\r\n      } else {\r\n        marginWidth += this.$options.margin;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-left',\r\n          this.$options.margin + 'px'\r\n        );\r\n      }\r\n      if (this.$options.outerMarginRight !== null) {\r\n        marginWidth += this.$options.outerMarginRight;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-right',\r\n          this.$options.outerMarginRight + 'px'\r\n        );\r\n      } else {\r\n        marginWidth += this.$options.margin;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-right',\r\n          this.$options.margin + 'px'\r\n        );\r\n      }\r\n      this.curColWidth = (this.curWidth - marginWidth) / this.columns;\r\n      let marginHeight = -this.$options.margin;\r\n      if (this.$options.outerMarginTop !== null) {\r\n        marginHeight += this.$options.outerMarginTop;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-top',\r\n          this.$options.outerMarginTop + 'px'\r\n        );\r\n      } else {\r\n        marginHeight += this.$options.margin;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-top',\r\n          this.$options.margin + 'px'\r\n        );\r\n      }\r\n      if (this.$options.outerMarginBottom !== null) {\r\n        marginHeight += this.$options.outerMarginBottom;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-bottom',\r\n          this.$options.outerMarginBottom + 'px'\r\n        );\r\n      } else {\r\n        marginHeight += this.$options.margin;\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'padding-bottom',\r\n          this.$options.margin + 'px'\r\n        );\r\n      }\r\n      this.curRowHeight =\r\n        ((this.curHeight - marginHeight) / this.rows) *\r\n        this.$options.rowHeightRatio;\r\n    } else {\r\n      this.curColWidth = (this.curWidth + this.$options.margin) / this.columns;\r\n      this.curRowHeight =\r\n        ((this.curHeight + this.$options.margin) / this.rows) *\r\n        this.$options.rowHeightRatio;\r\n      this.renderer.setStyle(this.el, 'padding-left', 0 + 'px');\r\n      this.renderer.setStyle(this.el, 'padding-right', 0 + 'px');\r\n      this.renderer.setStyle(this.el, 'padding-top', 0 + 'px');\r\n      this.renderer.setStyle(this.el, 'padding-bottom', 0 + 'px');\r\n    }\r\n    this.gridRenderer.updateGridster();\r\n\r\n    if (this.$options.setGridSize) {\r\n      this.renderer.addClass(this.el, 'gridSize');\r\n      if (!this.mobile) {\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'width',\r\n          this.columns * this.curColWidth + this.$options.margin + 'px'\r\n        );\r\n        this.renderer.setStyle(\r\n          this.el,\r\n          'height',\r\n          this.rows * this.curRowHeight + this.$options.margin + 'px'\r\n        );\r\n      }\r\n    } else {\r\n      this.renderer.removeClass(this.el, 'gridSize');\r\n      this.renderer.setStyle(this.el, 'width', '');\r\n      this.renderer.setStyle(this.el, 'height', '');\r\n    }\r\n    this.updateGrid();\r\n\r\n    let widgetsIndex: number = this.grid.length - 1;\r\n    let widget: GridsterItemComponentInterface;\r\n    for (; widgetsIndex >= 0; widgetsIndex--) {\r\n      widget = this.grid[widgetsIndex];\r\n      widget.setSize();\r\n      widget.drag.toggle();\r\n      widget.resize.toggle();\r\n    }\r\n\r\n    this.resize$.next();\r\n  }\r\n\r\n  updateGrid(): void {\r\n    if (this.$options.displayGrid === 'always' && !this.mobile) {\r\n      this.renderer.addClass(this.el, 'display-grid');\r\n    } else if (\r\n      this.$options.displayGrid === 'onDrag&Resize' &&\r\n      this.dragInProgress\r\n    ) {\r\n      this.renderer.addClass(this.el, 'display-grid');\r\n    } else if (\r\n      this.$options.displayGrid === 'none' ||\r\n      !this.dragInProgress ||\r\n      this.mobile\r\n    ) {\r\n      this.renderer.removeClass(this.el, 'display-grid');\r\n    }\r\n    this.setGridDimensions();\r\n    this.gridColumns.length = GridsterComponent.getNewArrayLength(\r\n      this.columns,\r\n      this.curWidth,\r\n      this.curColWidth\r\n    );\r\n    this.gridRows.length = GridsterComponent.getNewArrayLength(\r\n      this.rows,\r\n      this.curHeight,\r\n      this.curRowHeight\r\n    );\r\n    this.cdRef.markForCheck();\r\n  }\r\n\r\n  addItem(itemComponent: GridsterItemComponentInterface): void {\r\n    if (itemComponent.$item.cols === undefined) {\r\n      itemComponent.$item.cols = this.$options.defaultItemCols;\r\n      itemComponent.item.cols = itemComponent.$item.cols;\r\n      itemComponent.itemChanged();\r\n    }\r\n    if (itemComponent.$item.rows === undefined) {\r\n      itemComponent.$item.rows = this.$options.defaultItemRows;\r\n      itemComponent.item.rows = itemComponent.$item.rows;\r\n      itemComponent.itemChanged();\r\n    }\r\n    if (itemComponent.$item.x === -1 || itemComponent.$item.y === -1) {\r\n      this.autoPositionItem(itemComponent);\r\n    } else if (this.checkCollision(itemComponent.$item)) {\r\n      if (!this.$options.disableWarnings) {\r\n        itemComponent.notPlaced = true;\r\n        console.warn(\r\n          \"Can't be placed in the bounds of the dashboard, trying to auto position!/n\" +\r\n          JSON.stringify(itemComponent.item, ['cols', 'rows', 'x', 'y'])\r\n        );\r\n      }\r\n      if (!this.$options.disableAutoPositionOnConflict) {\r\n        this.autoPositionItem(itemComponent);\r\n      } else {\r\n        itemComponent.notPlaced = true;\r\n      }\r\n    }\r\n    this.grid.push(itemComponent);\r\n    this.calculateLayout$.next();\r\n  }\r\n\r\n  removeItem(itemComponent: GridsterItemComponentInterface): void {\r\n    this.grid.splice(this.grid.indexOf(itemComponent), 1);\r\n    this.calculateLayout$.next();\r\n    if (this.options.itemRemovedCallback) {\r\n      this.options.itemRemovedCallback(itemComponent.item, itemComponent);\r\n    }\r\n  }\r\n\r\n  checkCollision(item: GridsterItem): GridsterItemComponentInterface | boolean {\r\n    let collision: GridsterItemComponentInterface | boolean = false;\r\n    if (this.options.itemValidateCallback) {\r\n      collision = !this.options.itemValidateCallback(item);\r\n    }\r\n    if (!collision && this.checkGridCollision(item)) {\r\n      collision = true;\r\n    }\r\n    if (!collision) {\r\n      const c = this.findItemWithItem(item);\r\n      if (c) {\r\n        collision = c;\r\n      }\r\n    }\r\n    return collision;\r\n  }\r\n\r\n  checkGridCollision(item: GridsterItem): boolean {\r\n    const noNegativePosition = item.y > -1 && item.x > -1;\r\n    const maxGridCols = item.cols + item.x <= this.$options.maxCols;\r\n    const maxGridRows = item.rows + item.y <= this.$options.maxRows;\r\n    const maxItemCols =\r\n      item.maxItemCols === undefined\r\n        ? this.$options.maxItemCols\r\n        : item.maxItemCols;\r\n    const minItemCols =\r\n      item.minItemCols === undefined\r\n        ? this.$options.minItemCols\r\n        : item.minItemCols;\r\n    const maxItemRows =\r\n      item.maxItemRows === undefined\r\n        ? this.$options.maxItemRows\r\n        : item.maxItemRows;\r\n    const minItemRows =\r\n      item.minItemRows === undefined\r\n        ? this.$options.minItemRows\r\n        : item.minItemRows;\r\n    const inColsLimits = item.cols <= maxItemCols && item.cols >= minItemCols;\r\n    const inRowsLimits = item.rows <= maxItemRows && item.rows >= minItemRows;\r\n    const minAreaLimit =\r\n      item.minItemArea === undefined\r\n        ? this.$options.minItemArea\r\n        : item.minItemArea;\r\n    const maxAreaLimit =\r\n      item.maxItemArea === undefined\r\n        ? this.$options.maxItemArea\r\n        : item.maxItemArea;\r\n    const area = item.cols * item.rows;\r\n    const inMinArea = minAreaLimit <= area;\r\n    const inMaxArea = maxAreaLimit >= area;\r\n    return !(\r\n      noNegativePosition &&\r\n      maxGridCols &&\r\n      maxGridRows &&\r\n      inColsLimits &&\r\n      inRowsLimits &&\r\n      inMinArea &&\r\n      inMaxArea\r\n    );\r\n  }\r\n\r\n  findItemWithItem(\r\n    item: GridsterItem\r\n  ): GridsterItemComponentInterface | boolean {\r\n    let widgetsIndex = 0;\r\n    let widget: GridsterItemComponentInterface;\r\n    for (; widgetsIndex < this.grid.length; widgetsIndex++) {\r\n      widget = this.grid[widgetsIndex];\r\n      if (\r\n        widget.$item !== item &&\r\n        this.checkCollisionTwoItems(widget.$item, item)\r\n      ) {\r\n        return widget;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  findItemsWithItem(item: GridsterItem): Array<GridsterItemComponentInterface> {\r\n    const a: Array<GridsterItemComponentInterface> = [];\r\n    let widgetsIndex = 0;\r\n    let widget: GridsterItemComponentInterface;\r\n    for (; widgetsIndex < this.grid.length; widgetsIndex++) {\r\n      widget = this.grid[widgetsIndex];\r\n      if (\r\n        widget.$item !== item &&\r\n        this.checkCollisionTwoItems(widget.$item, item)\r\n      ) {\r\n        a.push(widget);\r\n      }\r\n    }\r\n    return a;\r\n  }\r\n\r\n  autoPositionItem(itemComponent: GridsterItemComponentInterface): void {\r\n    if (this.getNextPossiblePosition(itemComponent.$item)) {\r\n      itemComponent.notPlaced = false;\r\n      itemComponent.item.x = itemComponent.$item.x;\r\n      itemComponent.item.y = itemComponent.$item.y;\r\n      itemComponent.itemChanged();\r\n    } else {\r\n      itemComponent.notPlaced = true;\r\n      if (!this.$options.disableWarnings) {\r\n        console.warn(\r\n          \"Can't be placed in the bounds of the dashboard!/n\" +\r\n          JSON.stringify(itemComponent.item, ['cols', 'rows', 'x', 'y'])\r\n        );\r\n      }\r\n    }\r\n  }\r\n\r\n  getNextPossiblePosition = (\r\n    newItem: GridsterItem,\r\n    startingFrom: { y?: number; x?: number } = {}\r\n  ): boolean => {\r\n    if (newItem.cols === -1) {\r\n      newItem.cols = this.$options.defaultItemCols;\r\n    }\r\n    if (newItem.rows === -1) {\r\n      newItem.rows = this.$options.defaultItemRows;\r\n    }\r\n    this.setGridDimensions();\r\n    let rowsIndex = startingFrom.y || 0;\r\n    let colsIndex;\r\n    for (; rowsIndex < this.rows; rowsIndex++) {\r\n      newItem.y = rowsIndex;\r\n      colsIndex = startingFrom.x || 0;\r\n      for (; colsIndex < this.columns; colsIndex++) {\r\n        newItem.x = colsIndex;\r\n        if (!this.checkCollision(newItem)) {\r\n          return true;\r\n        }\r\n      }\r\n    }\r\n    const canAddToRows = this.$options.maxRows >= this.rows + newItem.rows;\r\n    const canAddToColumns =\r\n      this.$options.maxCols >= this.columns + newItem.cols;\r\n    const addToRows = this.rows <= this.columns && canAddToRows;\r\n    if (!addToRows && canAddToColumns) {\r\n      newItem.x = this.columns;\r\n      newItem.y = 0;\r\n      return true;\r\n    } else if (canAddToRows) {\r\n      newItem.y = this.rows;\r\n      newItem.x = 0;\r\n      return true;\r\n    }\r\n    return false;\r\n  };\r\n\r\n  getFirstPossiblePosition = (item: GridsterItem): GridsterItem => {\r\n    const tmpItem = Object.assign({}, item);\r\n    this.getNextPossiblePosition(tmpItem);\r\n    return tmpItem;\r\n  };\r\n\r\n  getLastPossiblePosition = (item: GridsterItem): GridsterItem => {\r\n    let farthestItem: { y: number; x: number } = { y: 0, x: 0 };\r\n    farthestItem = this.grid.reduce(\r\n      (\r\n        prev: { y: number; x: number },\r\n        curr: GridsterItemComponentInterface\r\n      ) => {\r\n        const currCoords = {\r\n          y: curr.$item.y + curr.$item.rows - 1,\r\n          x: curr.$item.x + curr.$item.cols - 1\r\n        };\r\n        if (GridsterUtils.compareItems(prev, currCoords) === 1) {\r\n          return currCoords;\r\n        } else {\r\n          return prev;\r\n        }\r\n      },\r\n      farthestItem\r\n    );\r\n\r\n    const tmpItem = Object.assign({}, item);\r\n    this.getNextPossiblePosition(tmpItem, farthestItem);\r\n    return tmpItem;\r\n  };\r\n\r\n  pixelsToPositionX(\r\n    x: number,\r\n    roundingMethod: (x: number) => number,\r\n    noLimit?: boolean\r\n  ): number {\r\n    const position = roundingMethod(x / this.curColWidth);\r\n    if (noLimit) {\r\n      return position;\r\n    } else {\r\n      return Math.max(position, 0);\r\n    }\r\n  }\r\n\r\n  pixelsToPositionY(\r\n    y: number,\r\n    roundingMethod: (x: number) => number,\r\n    noLimit?: boolean\r\n  ): number {\r\n    const position = roundingMethod(y / this.curRowHeight);\r\n    if (noLimit) {\r\n      return position;\r\n    } else {\r\n      return Math.max(position, 0);\r\n    }\r\n  }\r\n\r\n  positionXToPixels(x: number): number {\r\n    return x * this.curColWidth;\r\n  }\r\n\r\n  positionYToPixels(y: number): number {\r\n    return y * this.curRowHeight;\r\n  }\r\n\r\n  getItemComponent(\r\n    item: GridsterItem\r\n  ): GridsterItemComponentInterface | undefined {\r\n    return this.grid.find(c => c.item === item);\r\n  }\r\n\r\n  // ------ Functions for swapWhileDragging option\r\n\r\n  // identical to checkCollision() except that this function calls findItemWithItemForSwaping() instead of findItemWithItem()\r\n  checkCollisionForSwaping(\r\n    item: GridsterItem\r\n  ): GridsterItemComponentInterface | boolean {\r\n    let collision: GridsterItemComponentInterface | boolean = false;\r\n    if (this.options.itemValidateCallback) {\r\n      collision = !this.options.itemValidateCallback(item);\r\n    }\r\n    if (!collision && this.checkGridCollision(item)) {\r\n      collision = true;\r\n    }\r\n    if (!collision) {\r\n      const c = this.findItemWithItemForSwapping(item);\r\n      if (c) {\r\n        collision = c;\r\n      }\r\n    }\r\n    return collision;\r\n  }\r\n\r\n  // identical to findItemWithItem() except that this function calls checkCollisionTwoItemsForSwaping() instead of checkCollisionTwoItems()\r\n  findItemWithItemForSwapping(\r\n    item: GridsterItem\r\n  ): GridsterItemComponentInterface | boolean {\r\n    let widgetsIndex: number = this.grid.length - 1;\r\n    let widget: GridsterItemComponentInterface;\r\n    for (; widgetsIndex > -1; widgetsIndex--) {\r\n      widget = this.grid[widgetsIndex];\r\n      if (\r\n        widget.$item !== item &&\r\n        GridsterComponent.checkCollisionTwoItemsForSwaping(widget.$item, item)\r\n      ) {\r\n        return widget;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  previewStyle(drag = false): void {\r\n    if (this.movingItem) {\r\n      if (this.compact && drag) {\r\n        this.compact.checkCompactItem(this.movingItem);\r\n      }\r\n      this.previewStyle$.next(this.movingItem);\r\n    } else {\r\n      this.previewStyle$.next(null);\r\n    }\r\n  }\r\n\r\n  // ------ End of functions for swapWhileDragging option\r\n\r\n  // eslint-disable-next-line @typescript-eslint/member-ordering\r\n  private static getNewArrayLength(\r\n    length: number,\r\n    overallSize: number,\r\n    size: number\r\n  ): number {\r\n    const newLength = Math.max(length, Math.floor(overallSize / size));\r\n\r\n    if (newLength < 0) {\r\n      return 0;\r\n    }\r\n\r\n    if (Number.isFinite(newLength)) {\r\n      return Math.floor(newLength);\r\n    }\r\n\r\n    return 0;\r\n  }\r\n}\r\n","<div\r\n  class=\"gridster-column\"\r\n  *ngFor=\"let column of gridColumns; let i = index;\"\r\n  [ngStyle]=\"gridRenderer.getGridColumnStyle(i)\"\r\n></div>\r\n<div\r\n  class=\"gridster-row\"\r\n  *ngFor=\"let row of gridRows; let i = index;\"\r\n  [ngStyle]=\"gridRenderer.getGridRowStyle(i)\"\r\n></div>\r\n<ng-content></ng-content>\r\n<gridster-preview\r\n  [gridRenderer]=\"gridRenderer\"\r\n  [previewStyle$]=\"previewStyle$\"\r\n  class=\"gridster-preview\"\r\n></gridster-preview>\r\n"]}