@schneideress/dashboardframework 13.0.0 → 17.0.1

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