barsa-user-workspace 0.0.0-watch

package/esm2022/lib/grid/grid.component.mjs

@@ -0,0 +1,609 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { coerceNumberProperty } from '../coercion/number-property';
+import { KtdGridItemComponent } from '../grid-item/grid-item.component';
+import { combineLatest, merge, NEVER, Observable, of } from 'rxjs';
+import { exhaustMap, map, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { ktdGetGridItemRowHeight, ktdGridItemDragging, ktdGridItemLayoutItemAreEqual, ktdGridItemResizing } from '../utils/grid.utils';
+import { compact } from '../utils/react-grid-layout.utils';
+import { GRID_ITEM_GET_RENDER_DATA_TOKEN } from '../grid.definitions';
+import { ktdPointerUp, ktdPointerClientX, ktdPointerClientY } from '../utils/pointer.utils';
+import { getMutableClientRect } from '../utils/client-rect';
+import { ktdGetScrollTotalRelativeDifference$, ktdScrollIfNearElementClientRect$ } from '../utils/scroll';
+import { coerceBooleanProperty } from '../coercion/boolean-property';
+import { getTransformTransitionDurationInMs } from '../utils/transition-duration';
+import * as i0 from "@angular/core";
+import * as i1 from "../grid.service";
+function getDragResizeEventData(gridItem, layout) {
+    return {
+        layout,
+        layoutItem: layout.find((item) => item.id === gridItem.id),
+        gridItemRef: gridItem
+    };
+}
+function getColumnWidth(config, width) {
+    const { cols, gap } = config;
+    const widthExcludingGap = width - Math.max(gap * (cols - 1), 0);
+    return widthExcludingGap / cols;
+}
+function getRowHeightInPixels(config, height) {
+    const { rowHeight, layout, gap } = config;
+    return rowHeight === 'fit' ? ktdGetGridItemRowHeight(layout, height, gap) : rowHeight;
+}
+function layoutToRenderItems(config, width, height) {
+    const { layout, gap } = config;
+    const rowHeightInPixels = getRowHeightInPixels(config, height);
+    const itemWidthPerColumn = getColumnWidth(config, width);
+    const renderItems = {};
+    for (const item of layout) {
+        renderItems[item.id] = {
+            id: item.id,
+            top: item.y * rowHeightInPixels + gap * item.y,
+            left: item.x * itemWidthPerColumn + gap * item.x,
+            width: item.w * itemWidthPerColumn + gap * Math.max(item.w - 1, 0),
+            height: item.h * rowHeightInPixels + gap * Math.max(item.h - 1, 0)
+        };
+    }
+    return renderItems;
+}
+function getGridHeight(layout, rowHeight, gap) {
+    return layout.reduce((acc, cur) => Math.max(acc, (cur.y + cur.h) * rowHeight + Math.max(cur.y + cur.h - 1, 0) * gap), 0);
+}
+// eslint-disable-next-line
+export function parseRenderItemToPixels(renderItem) {
+    return {
+        id: renderItem.id,
+        top: `${renderItem.top}px`,
+        left: `${renderItem.left}px`,
+        width: `${renderItem.width}px`,
+        height: `${renderItem.height}px`
+    };
+}
+// eslint-disable-next-line
+export function __gridItemGetRenderDataFactoryFunc(gridCmp) {
+    return function (id) {
+        return parseRenderItemToPixels(gridCmp.getItemRenderData(id));
+    };
+}
+export function ktdGridItemGetRenderDataFactoryFunc(gridCmp) {
+    // Workaround explained: https://github.com/ng-packagr/ng-packagr/issues/696#issuecomment-387114613
+    const resultFunc = __gridItemGetRenderDataFactoryFunc(gridCmp);
+    return resultFunc;
+}
+const defaultBackgroundConfig = {
+    borderColor: '#ffa72678',
+    gapColor: 'transparent',
+    rowColor: 'transparent',
+    columnColor: 'transparent',
+    borderWidth: 1
+};
+export class KtdGridComponent {
+    /** Whether or not to update the internal layout when some dependent property change. */
+    get compactOnPropsChange() {
+        return this._compactOnPropsChange;
+    }
+    set compactOnPropsChange(value) {
+        this._compactOnPropsChange = coerceBooleanProperty(value);
+    }
+    /** If true, grid items won't change position when being dragged over. Handy when using no compaction */
+    get preventCollision() {
+        return this._preventCollision;
+    }
+    set preventCollision(value) {
+        this._preventCollision = coerceBooleanProperty(value);
+    }
+    /** Number of CSS pixels that would be scrolled on each 'tick' when auto scroll is performed. */
+    get scrollSpeed() {
+        return this._scrollSpeed;
+    }
+    set scrollSpeed(value) {
+        this._scrollSpeed = coerceNumberProperty(value, 2);
+    }
+    /** Type of compaction that will be applied to the layout (vertical, horizontal or free). Defaults to 'vertical' */
+    get compactType() {
+        return this._compactType;
+    }
+    set compactType(val) {
+        this._compactType = val;
+    }
+    /**
+     * Row height as number or as 'fit'.
+     * If rowHeight is a number value, it means that each row would have those css pixels in height.
+     * if rowHeight is 'fit', it means that rows will fit in the height available. If 'fit' value is set, a 'height' should be also provided.
+     */
+    get rowHeight() {
+        return this._rowHeight;
+    }
+    set rowHeight(val) {
+        this._rowHeight = val === 'fit' ? val : Math.max(1, Math.round(coerceNumberProperty(val)));
+    }
+    /** Number of columns  */
+    get cols() {
+        return this._cols;
+    }
+    set cols(val) {
+        this._cols = Math.max(1, Math.round(coerceNumberProperty(val)));
+    }
+    /** Layout of the grid. Array of all the grid items with its 'id' and position on the grid. */
+    get layout() {
+        return this._layout;
+    }
+    set layout(layout) {
+        /**
+         * Enhancement:
+         * Only set layout if it's reference has changed and use a boolean to track whenever recalculate the layout on ngOnChanges.
+         *
+         * Why:
+         * The normal use of this lib is having the variable layout in the outer component or in a store, assigning it whenever it changes and
+         * binded in the component with it's input [layout]. In this scenario, we would always calculate one unnecessary change on the layout when
+         * it is re-binded on the input.
+         */
+        this._layout = layout;
+    }
+    /** Grid gap in css pixels */
+    get gap() {
+        return this._gap;
+    }
+    set gap(val) {
+        this._gap = Math.max(coerceNumberProperty(val), 0);
+    }
+    /**
+     * If height is a number, fixes the height of the grid to it, recommended when rowHeight = 'fit' is used.
+     * If height is null, height will be automatically set according to its inner grid items.
+     * Defaults to null.
+     * */
+    get height() {
+        return this._height;
+    }
+    set height(val) {
+        this._height = typeof val === 'number' ? Math.max(val, 0) : null;
+    }
+    get backgroundConfig() {
+        return this._backgroundConfig;
+    }
+    set backgroundConfig(val) {
+        this._backgroundConfig = val;
+        // If there is background configuration, add main grid background class. Grid background class comes with opacity 0.
+        // It is done this way for adding opacity animation and to don't add any styles when grid background is null.
+        const classList = this.elementRef.nativeElement.classList;
+        this._backgroundConfig !== null
+            ? classList.add('buw-grid-background')
+            : classList.remove('buw-grid-background');
+        // Set background visibility
+        this.setGridBackgroundVisible(this._backgroundConfig?.show === 'always');
+    }
+    get config() {
+        return {
+            cols: this.cols,
+            rowHeight: this.rowHeight,
+            height: this.height,
+            layout: this.layout,
+            preventCollision: this.preventCollision,
+            gap: this.gap
+        };
+    }
+    constructor(gridService, elementRef, viewContainerRef, renderer, ngZone) {
+        this.gridService = gridService;
+        this.elementRef = elementRef;
+        this.viewContainerRef = viewContainerRef;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        /** Emits when layout change */
+        this.layoutUpdated = new EventEmitter();
+        /** Emits when drag starts */
+        this.dragStarted = new EventEmitter();
+        /** Emits when resize starts */
+        this.resizeStarted = new EventEmitter();
+        /** Emits when drag ends */
+        this.dragEnded = new EventEmitter();
+        /** Emits when resize ends */
+        this.resizeEnded = new EventEmitter();
+        /** Emits when a grid item is being resized and its bounds have changed */
+        this.gridItemResize = new EventEmitter();
+        /**
+         * Parent element that contains the scroll. If an string is provided it would search that element by id on the dom.
+         * If no data provided or null autoscroll is not performed.
+         */
+        this.scrollableParent = null;
+        this._compactOnPropsChange = true;
+        this._preventCollision = false;
+        this._scrollSpeed = 2;
+        this._compactType = 'vertical';
+        this._rowHeight = 100;
+        this._cols = 6;
+        this._gap = 0;
+        this._height = null;
+        this._backgroundConfig = null;
+        this.subscriptions = [];
+    }
+    ngOnChanges(changes) {
+        if (this.rowHeight === 'fit' && this.height == null) {
+            console.warn(`KtdGridComponent: The @Input() height should not be null when using rowHeight 'fit'`);
+        }
+        let needsCompactLayout = false;
+        let needsRecalculateRenderData = false;
+        // TODO: Does fist change need to be compacted by default?
+        // Compact layout whenever some dependent prop changes.
+        if (changes.compactType || changes.cols || changes.layout) {
+            needsCompactLayout = true;
+        }
+        // Check if wee need to recalculate rendering data.
+        if (needsCompactLayout || changes.rowHeight || changes.height || changes.gap || changes.backgroundConfig) {
+            needsRecalculateRenderData = true;
+        }
+        // Only compact layout if lib user has provided it. Lib users that want to save/store always the same layout  as it is represented (compacted)
+        // can use KtdCompactGrid utility and pre-compact the layout. This is the recommended behaviour for always having a the same layout on this component
+        // and the ones that uses it.
+        if (needsCompactLayout && this.compactOnPropsChange) {
+            this.compactLayout();
+        }
+        if (needsRecalculateRenderData) {
+            this.calculateRenderData();
+        }
+    }
+    ngAfterContentInit() {
+        this.initSubscriptions();
+    }
+    ngAfterContentChecked() {
+        this.render();
+    }
+    resize() {
+        this.calculateRenderData();
+        this.render();
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+    compactLayout() {
+        this.layout = compact(this.layout, this.compactType, this.cols);
+    }
+    getItemsRenderData() {
+        return { ...this._gridItemsRenderData };
+    }
+    getItemRenderData(itemId) {
+        return this._gridItemsRenderData[itemId];
+    }
+    calculateRenderData() {
+        const clientRect = this.elementRef.nativeElement.getBoundingClientRect();
+        this.gridCurrentHeight =
+            this.height ??
+                (this.rowHeight === 'fit' ? clientRect.height : getGridHeight(this.layout, this.rowHeight, this.gap));
+        this._gridItemsRenderData = layoutToRenderItems(this.config, clientRect.width, this.gridCurrentHeight);
+        // Set Background CSS variables
+        this.setBackgroundCssVariables(getRowHeightInPixels(this.config, this.gridCurrentHeight));
+    }
+    render() {
+        this.renderer.setStyle(this.elementRef.nativeElement, 'height', `${this.gridCurrentHeight}px`);
+        this.updateGridItemsStyles();
+    }
+    setBackgroundCssVariables(rowHeight) {
+        const style = this.elementRef.nativeElement.style;
+        if (this._backgroundConfig) {
+            // structure
+            style.setProperty('--gap', this.gap + 'px');
+            style.setProperty('--row-height', rowHeight + 'px');
+            style.setProperty('--columns', `${this.cols}`);
+            style.setProperty('--border-width', (this._backgroundConfig.borderWidth ?? defaultBackgroundConfig.borderWidth) + 'px');
+            // colors
+            style.setProperty('--border-color', this._backgroundConfig.borderColor ?? defaultBackgroundConfig.borderColor);
+            style.setProperty('--gap-color', this._backgroundConfig.gapColor ?? defaultBackgroundConfig.gapColor);
+            style.setProperty('--row-color', this._backgroundConfig.rowColor ?? defaultBackgroundConfig.rowColor);
+            style.setProperty('--column-color', this._backgroundConfig.columnColor ?? defaultBackgroundConfig.columnColor);
+        }
+        else {
+            style.removeProperty('--gap');
+            style.removeProperty('--row-height');
+            style.removeProperty('--columns');
+            style.removeProperty('--border-width');
+            style.removeProperty('--border-color');
+            style.removeProperty('--gap-color');
+            style.removeProperty('--row-color');
+            style.removeProperty('--column-color');
+        }
+    }
+    updateGridItemsStyles() {
+        this._gridItems.forEach((item) => {
+            const gridItemRenderData = this._gridItemsRenderData[item.id];
+            if (gridItemRenderData == null) {
+                console.error(`Couldn't find the specified grid item for the id: ${item.id}`);
+            }
+            else {
+                item.setStyles(parseRenderItemToPixels(gridItemRenderData));
+            }
+        });
+    }
+    setGridBackgroundVisible(visible) {
+        const classList = this.elementRef.nativeElement.classList;
+        visible ? classList.add('buw-grid-background-visible') : classList.remove('buw-grid-background-visible');
+    }
+    initSubscriptions() {
+        this.subscriptions = [
+            this._gridItems.changes
+                .pipe(startWith(this._gridItems), switchMap((gridItems) => merge(...gridItems.map((gridItem) => gridItem.dragStart$.pipe(map((event) => ({ event, gridItem, type: 'drag' })))), ...gridItems.map((gridItem) => gridItem.resizeStart$.pipe(map((event) => ({
+                event,
+                gridItem,
+                type: 'resize'
+            }))))).pipe(exhaustMap(({ event, gridItem, type }) => {
+                // Emit drag or resize start events. Ensure that is start event is inside the zone.
+                this.ngZone.run(() => (type === 'drag' ? this.dragStarted : this.resizeStarted).emit(getDragResizeEventData(gridItem, this.layout)));
+                this.setGridBackgroundVisible(this._backgroundConfig?.show === 'whenDragging' ||
+                    this._backgroundConfig?.show === 'always');
+                // Perform drag sequence
+                return this.performDragSequence$(gridItem, event, type).pipe(map((layout) => ({ layout, gridItem, type })));
+            }))))
+                .subscribe(({ layout, gridItem, type }) => {
+                this.layout = layout;
+                // Calculate new rendering data given the new layout.
+                this.calculateRenderData();
+                // Emit drag or resize end events.
+                (type === 'drag' ? this.dragEnded : this.resizeEnded).emit(getDragResizeEventData(gridItem, layout));
+                // Notify that the layout has been updated.
+                this.layoutUpdated.emit(layout);
+                this.setGridBackgroundVisible(this._backgroundConfig?.show === 'always');
+            })
+        ];
+    }
+    /**
+     * Perform a general grid drag action, from start to end. A general grid drag action basically includes creating the placeholder element and adding
+     * some class animations. calcNewStateFunc needs to be provided in order to calculate the new state of the layout.
+     * @param gridItem that is been dragged
+     * @param pointerDownEvent event (mousedown or touchdown) where the user initiated the drag
+     * @param calcNewStateFunc function that return the new layout state and the drag element position
+     */
+    performDragSequence$(gridItem, pointerDownEvent, type) {
+        return new Observable((observer) => {
+            // Retrieve grid (parent) and gridItem (draggedElem) client rects.
+            const gridElemClientRect = getMutableClientRect(this.elementRef.nativeElement);
+            const dragElemClientRect = getMutableClientRect(gridItem.elementRef.nativeElement);
+            const scrollableParent = typeof this.scrollableParent === 'string'
+                ? document.getElementById(this.scrollableParent)
+                : this.scrollableParent;
+            this.renderer.addClass(gridItem.elementRef.nativeElement, 'no-transitions');
+            this.renderer.addClass(gridItem.elementRef.nativeElement, 'buw-grid-item-dragging');
+            const placeholderClientRect = {
+                ...dragElemClientRect,
+                left: dragElemClientRect.left - gridElemClientRect.left,
+                top: dragElemClientRect.top - gridElemClientRect.top
+            };
+            this.createPlaceholderElement(placeholderClientRect, gridItem.placeholder);
+            let newLayout;
+            // TODO (enhancement): consider move this 'side effect' observable inside the main drag loop.
+            //  - Pros are that we would not repeat subscriptions and takeUntil would shut down observables at the same time.
+            //  - Cons are that moving this functionality as a side effect inside the main drag loop would be confusing.
+            const scrollSubscription = this.ngZone.runOutsideAngular(() => (!scrollableParent
+                ? NEVER
+                : this.gridService.mouseOrTouchMove$(document).pipe(map((event) => ({
+                    pointerX: ktdPointerClientX(event),
+                    pointerY: ktdPointerClientY(event)
+                })), ktdScrollIfNearElementClientRect$(scrollableParent, { scrollStep: this.scrollSpeed })))
+                .pipe(takeUntil(ktdPointerUp(document)))
+                .subscribe());
+            /**
+             * Main subscription, it listens for 'pointer move' and 'scroll' events and recalculates the layout on each emission
+             */
+            const subscription = this.ngZone.runOutsideAngular(() => merge(combineLatest([
+                this.gridService.mouseOrTouchMove$(document),
+                ...(!scrollableParent
+                    ? [of({ top: 0, left: 0 })]
+                    : [
+                        ktdGetScrollTotalRelativeDifference$(scrollableParent).pipe(startWith({ top: 0, left: 0 }) // Force first emission to allow CombineLatest to emit even no scroll event has occurred
+                        )
+                    ])
+            ]))
+                .pipe(takeUntil(ktdPointerUp(document)))
+                .subscribe(([pointerDragEvent, scrollDifference]) => {
+                pointerDragEvent.preventDefault();
+                /**
+                 * Set the new layout to be the layout in which the calcNewStateFunc would be executed.
+                 * NOTE: using the mutated layout is the way to go by 'react-grid-layout' utils. If we don't use the previous layout,
+                 * some utilities from 'react-grid-layout' would not work as expected.
+                 */
+                const currentLayout = newLayout || this.layout;
+                // Get the correct newStateFunc depending on if we are dragging or resizing
+                const calcNewStateFunc = type === 'drag' ? ktdGridItemDragging : ktdGridItemResizing;
+                const { layout, draggedItemPos } = calcNewStateFunc(gridItem, {
+                    layout: currentLayout,
+                    rowHeight: this.rowHeight,
+                    height: this.height,
+                    cols: this.cols,
+                    preventCollision: this.preventCollision,
+                    gap: this.gap
+                }, this.compactType, {
+                    pointerDownEvent,
+                    pointerDragEvent,
+                    gridElemClientRect,
+                    dragElemClientRect,
+                    scrollDifference
+                });
+                newLayout = layout;
+                this.gridCurrentHeight =
+                    this.height ??
+                        (this.rowHeight === 'fit'
+                            ? gridElemClientRect.height
+                            : getGridHeight(newLayout, this.rowHeight, this.gap));
+                this._gridItemsRenderData = layoutToRenderItems({
+                    cols: this.cols,
+                    rowHeight: this.rowHeight,
+                    height: this.height,
+                    layout: newLayout,
+                    preventCollision: this.preventCollision,
+                    gap: this.gap
+                }, gridElemClientRect.width, gridElemClientRect.height);
+                const newGridItemRenderData = { ...this._gridItemsRenderData[gridItem.id] };
+                const placeholderStyles = parseRenderItemToPixels(newGridItemRenderData);
+                // Put the real final position to the placeholder element
+                this.placeholder.style.width = placeholderStyles.width;
+                this.placeholder.style.height = placeholderStyles.height;
+                this.placeholder.style.transform = `translateX(${placeholderStyles.left}) translateY(${placeholderStyles.top})`;
+                // modify the position of the dragged item to be the once we want (for example the mouse position or whatever)
+                this._gridItemsRenderData[gridItem.id] = {
+                    ...draggedItemPos,
+                    id: this._gridItemsRenderData[gridItem.id].id
+                };
+                this.setBackgroundCssVariables(this.rowHeight === 'fit'
+                    ? ktdGetGridItemRowHeight(newLayout, gridElemClientRect.height, this.gap)
+                    : this.rowHeight);
+                this.render();
+                // If we are performing a resize, and bounds have changed, emit event.
+                // NOTE: Only emit on resize for now. Use case for normal drag is not justified for now. Emitting on resize is,
+                // since we may want to re-render the grid item or the placeholder in order to fit the new bounds.
+                if (type === 'resize') {
+                    const prevGridItem = currentLayout.find((item) => item.id === gridItem.id);
+                    const newGridItem = newLayout.find((item) => item.id === gridItem.id);
+                    // Check if item resized has changed, if so, emit resize change event
+                    if (!ktdGridItemLayoutItemAreEqual(prevGridItem, newGridItem)) {
+                        this.gridItemResize.emit({
+                            width: newGridItemRenderData.width,
+                            height: newGridItemRenderData.height,
+                            gridItemRef: getDragResizeEventData(gridItem, newLayout).gridItemRef
+                        });
+                    }
+                }
+            }, (error) => observer.error(error), () => {
+                this.ngZone.run(() => {
+                    // Remove drag classes
+                    this.renderer.removeClass(gridItem.elementRef.nativeElement, 'no-transitions');
+                    this.renderer.removeClass(gridItem.elementRef.nativeElement, 'buw-grid-item-dragging');
+                    this.addGridItemAnimatingClass(gridItem).subscribe();
+                    // Consider destroying the placeholder after the animation has finished.
+                    this.destroyPlaceholder();
+                    if (newLayout) {
+                        // TODO: newLayout should already be pruned. If not, it should have type Layout, not KtdGridLayout as it is now.
+                        // Prune react-grid-layout compact extra properties.
+                        observer.next(newLayout.map((item) => ({
+                            id: item.id,
+                            x: item.x,
+                            y: item.y,
+                            w: item.w,
+                            h: item.h,
+                            minW: item.minW,
+                            minH: item.minH,
+                            maxW: item.maxW,
+                            maxH: item.maxH
+                        })));
+                    }
+                    else {
+                        // TODO: Need we really to emit if there is no layout change but drag started and ended?
+                        observer.next(this.layout);
+                    }
+                    observer.complete();
+                });
+            }));
+            return () => {
+                scrollSubscription.unsubscribe();
+                subscription.unsubscribe();
+            };
+        });
+    }
+    /**
+     * It adds the `buw-grid-item-animating` class and removes it when the animated transition is complete.
+     * This function is meant to be executed when the drag has ended.
+     * @param gridItem that has been dragged
+     */
+    addGridItemAnimatingClass(gridItem) {
+        return new Observable((observer) => {
+            const duration = getTransformTransitionDurationInMs(gridItem.elementRef.nativeElement);
+            if (duration === 0) {
+                observer.next();
+                observer.complete();
+                return;
+            }
+            this.renderer.addClass(gridItem.elementRef.nativeElement, 'buw-grid-item-animating');
+            const handler = ((event) => {
+                if (!event ||
+                    (event.target === gridItem.elementRef.nativeElement && event.propertyName === 'transform')) {
+                    this.renderer.removeClass(gridItem.elementRef.nativeElement, 'buw-grid-item-animating');
+                    removeEventListener();
+                    clearTimeout(timeout);
+                    observer.next();
+                    observer.complete();
+                }
+            });
+            // If a transition is short enough, the browser might not fire the `transitionend` event.
+            // Since we know how long it's supposed to take, add a timeout with a 50% buffer that'll
+            // fire if the transition hasn't completed when it was supposed to.
+            const timeout = setTimeout(handler, duration * 1.5);
+            const removeEventListener = this.renderer.listen(gridItem.elementRef.nativeElement, 'transitionend', handler);
+        });
+    }
+    /** Creates placeholder element */
+    createPlaceholderElement(clientRect, gridItemPlaceholder) {
+        this.placeholder = this.renderer.createElement('div');
+        this.placeholder.style.width = `${clientRect.width}px`;
+        this.placeholder.style.height = `${clientRect.height}px`;
+        this.placeholder.style.transform = `translateX(${clientRect.left}px) translateY(${clientRect.top}px)`;
+        this.placeholder.classList.add('buw-grid-item-placeholder');
+        this.renderer.appendChild(this.elementRef.nativeElement, this.placeholder);
+        // Create and append custom placeholder if provided.
+        // Important: Append it after creating & appending the container placeholder. This way we ensure parent bounds are set when creating the embeddedView.
+        if (gridItemPlaceholder) {
+            this.placeholderRef = this.viewContainerRef.createEmbeddedView(gridItemPlaceholder.templateRef, gridItemPlaceholder.data);
+            this.placeholderRef.rootNodes.forEach((node) => this.placeholder.appendChild(node));
+            this.placeholderRef.detectChanges();
+        }
+        else {
+            this.placeholder.classList.add('buw-grid-item-placeholder-default');
+        }
+    }
+    /** Destroys the placeholder element and its ViewRef. */
+    destroyPlaceholder() {
+        this.placeholder?.remove();
+        this.placeholderRef?.destroy();
+        this.placeholder = this.placeholderRef = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridComponent, deps: [{ token: i1.KtdGridService }, { token: i0.ElementRef }, { token: i0.ViewContainerRef }, { token: i0.Renderer2 }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: KtdGridComponent, selector: "buw-grid", inputs: { scrollableParent: "scrollableParent", compactOnPropsChange: "compactOnPropsChange", preventCollision: "preventCollision", scrollSpeed: "scrollSpeed", compactType: "compactType", rowHeight: "rowHeight", cols: "cols", layout: "layout", gap: "gap", height: "height", backgroundConfig: "backgroundConfig" }, outputs: { layoutUpdated: "layoutUpdated", dragStarted: "dragStarted", resizeStarted: "resizeStarted", dragEnded: "dragEnded", resizeEnded: "resizeEnded", gridItemResize: "gridItemResize" }, providers: [
+            {
+                provide: GRID_ITEM_GET_RENDER_DATA_TOKEN,
+                useFactory: ktdGridItemGetRenderDataFactoryFunc,
+                deps: [KtdGridComponent]
+            }
+        ], queries: [{ propertyName: "_gridItems", predicate: KtdGridItemComponent, descendants: true }], usesOnChanges: true, ngImport: i0, template: "<ng-content></ng-content>", styles: ["buw-grid{display:block;position:relative;width:100%}buw-grid.buw-grid-background:before{content:\"\";border:none;position:absolute;inset:0;z-index:0;transition:opacity .2s;opacity:0;background-image:repeating-linear-gradient(var(--border-color) 0 var(--border-width),var(--row-color) var(--border-width) calc(var(--row-height) - var(--border-width)),var(--border-color) calc(var(--row-height) - var(--border-width)) calc(var(--row-height)),var(--gap-color) calc(var(--row-height)) calc(var(--row-height) + var(--gap))),repeating-linear-gradient(90deg,var(--border-color) 0 var(--border-width),var(--column-color) var(--border-width) calc(100% - (var(--border-width) + var(--gap))),var(--border-color) calc(100% - (var(--border-width) + var(--gap))) calc(100% - var(--gap)),var(--gap-color) calc(100% - var(--gap)) 100%);background-size:calc((100% + var(--gap)) / var(--columns)) calc(var(--row-height) + var(--gap));background-position:0 0}buw-grid.buw-grid-background.buw-grid-background-visible:before{opacity:1}buw-grid buw-grid-item.buw-grid-item-dragging,buw-grid buw-grid-item.buw-grid-item-animating{z-index:1000}buw-grid buw-grid-item.no-transitions{transition:none!important}buw-grid .buw-grid-item-placeholder{position:absolute;z-index:0;transition-property:transform;transition:all .15s ease}buw-grid .buw-grid-item-placeholder-default{background-color:#8b0000;opacity:.6}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'buw-grid', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: GRID_ITEM_GET_RENDER_DATA_TOKEN,
+                            useFactory: ktdGridItemGetRenderDataFactoryFunc,
+                            deps: [KtdGridComponent]
+                        }
+                    ], template: "<ng-content></ng-content>", styles: ["buw-grid{display:block;position:relative;width:100%}buw-grid.buw-grid-background:before{content:\"\";border:none;position:absolute;inset:0;z-index:0;transition:opacity .2s;opacity:0;background-image:repeating-linear-gradient(var(--border-color) 0 var(--border-width),var(--row-color) var(--border-width) calc(var(--row-height) - var(--border-width)),var(--border-color) calc(var(--row-height) - var(--border-width)) calc(var(--row-height)),var(--gap-color) calc(var(--row-height)) calc(var(--row-height) + var(--gap))),repeating-linear-gradient(90deg,var(--border-color) 0 var(--border-width),var(--column-color) var(--border-width) calc(100% - (var(--border-width) + var(--gap))),var(--border-color) calc(100% - (var(--border-width) + var(--gap))) calc(100% - var(--gap)),var(--gap-color) calc(100% - var(--gap)) 100%);background-size:calc((100% + var(--gap)) / var(--columns)) calc(var(--row-height) + var(--gap));background-position:0 0}buw-grid.buw-grid-background.buw-grid-background-visible:before{opacity:1}buw-grid buw-grid-item.buw-grid-item-dragging,buw-grid buw-grid-item.buw-grid-item-animating{z-index:1000}buw-grid buw-grid-item.no-transitions{transition:none!important}buw-grid .buw-grid-item-placeholder{position:absolute;z-index:0;transition-property:transform;transition:all .15s ease}buw-grid .buw-grid-item-placeholder-default{background-color:#8b0000;opacity:.6}\n"] }]
+        }], ctorParameters: () => [{ type: i1.KtdGridService }, { type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i0.Renderer2 }, { type: i0.NgZone }], propDecorators: { _gridItems: [{
+                type: ContentChildren,
+                args: [KtdGridItemComponent, { descendants: true }]
+            }], layoutUpdated: [{
+                type: Output
+            }], dragStarted: [{
+                type: Output
+            }], resizeStarted: [{
+                type: Output
+            }], dragEnded: [{
+                type: Output
+            }], resizeEnded: [{
+                type: Output
+            }], gridItemResize: [{
+                type: Output
+            }], scrollableParent: [{
+                type: Input
+            }], compactOnPropsChange: [{
+                type: Input
+            }], preventCollision: [{
+                type: Input
+            }], scrollSpeed: [{
+                type: Input
+            }], compactType: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], cols: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], gap: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], backgroundConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid.component.js","sourceRoot":"","sources":["../../../../../projects/barsa-user-workspace/src/lib/grid/grid.component.ts","../../../../../projects/barsa-user-workspace/src/lib/grid/grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentChecked,\n    AfterContentInit,\n    ChangeDetectionStrategy,\n    Component,\n    ContentChildren,\n    ElementRef,\n    EmbeddedViewRef,\n    EventEmitter,\n    Input,\n    NgZone,\n    OnChanges,\n    OnDestroy,\n    Output,\n    QueryList,\n    Renderer2,\n    SimpleChanges,\n    ViewContainerRef,\n    ViewEncapsulation\n} from '@angular/core';\nimport { coerceNumberProperty, NumberInput } from '../coercion/number-property';\nimport { KtdGridItemComponent } from '../grid-item/grid-item.component';\nimport { combineLatest, merge, NEVER, Observable, Observer, of, Subscription } from 'rxjs';\nimport { exhaustMap, map, startWith, switchMap, takeUntil } from 'rxjs/operators';\nimport {\n    ktdGetGridItemRowHeight,\n    ktdGridItemDragging,\n    ktdGridItemLayoutItemAreEqual,\n    ktdGridItemResizing\n} from '../utils/grid.utils';\nimport { compact } from '../utils/react-grid-layout.utils';\nimport {\n    GRID_ITEM_GET_RENDER_DATA_TOKEN,\n    KtdGridBackgroundCfg,\n    KtdGridCfg,\n    KtdGridCompactType,\n    KtdGridItemRenderData,\n    KtdGridLayout,\n    KtdGridLayoutItem\n} from '../grid.definitions';\nimport { ktdPointerUp, ktdPointerClientX, ktdPointerClientY } from '../utils/pointer.utils';\nimport { KtdDictionary } from '../../types';\nimport { KtdGridService } from '../grid.service';\nimport { getMutableClientRect, KtdClientRect } from '../utils/client-rect';\nimport { ktdGetScrollTotalRelativeDifference$, ktdScrollIfNearElementClientRect$ } from '../utils/scroll';\nimport { BooleanInput, coerceBooleanProperty } from '../coercion/boolean-property';\nimport { KtdGridItemPlaceholder } from '../directives/placeholder';\nimport { getTransformTransitionDurationInMs } from '../utils/transition-duration';\n\ninterface KtdDragResizeEvent {\n    layout: KtdGridLayout;\n    layoutItem: KtdGridLayoutItem;\n    gridItemRef: KtdGridItemComponent;\n}\n\nexport type KtdDragStart = KtdDragResizeEvent;\nexport type KtdResizeStart = KtdDragResizeEvent;\nexport type KtdDragEnd = KtdDragResizeEvent;\nexport type KtdResizeEnd = KtdDragResizeEvent;\n\nexport interface KtdGridItemResizeEvent {\n    width: number;\n    height: number;\n    gridItemRef: KtdGridItemComponent;\n}\n\ntype DragActionType = 'drag' | 'resize';\n\nfunction getDragResizeEventData(gridItem: KtdGridItemComponent, layout: KtdGridLayout): KtdDragResizeEvent {\n    return {\n        layout,\n        layoutItem: layout.find((item) => item.id === gridItem.id)!,\n        gridItemRef: gridItem\n    };\n}\n\nfunction getColumnWidth(config: KtdGridCfg, width: number): number {\n    const { cols, gap } = config;\n    const widthExcludingGap = width - Math.max(gap * (cols - 1), 0);\n    return widthExcludingGap / cols;\n}\n\nfunction getRowHeightInPixels(config: KtdGridCfg, height: number): number {\n    const { rowHeight, layout, gap } = config;\n    return rowHeight === 'fit' ? ktdGetGridItemRowHeight(layout, height, gap) : rowHeight;\n}\n\nfunction layoutToRenderItems(\n    config: KtdGridCfg,\n    width: number,\n    height: number\n): KtdDictionary<KtdGridItemRenderData<number>> {\n    const { layout, gap } = config;\n    const rowHeightInPixels = getRowHeightInPixels(config, height);\n    const itemWidthPerColumn = getColumnWidth(config, width);\n    const renderItems: KtdDictionary<KtdGridItemRenderData<number>> = {};\n    for (const item of layout) {\n        renderItems[item.id] = {\n            id: item.id,\n            top: item.y * rowHeightInPixels + gap * item.y,\n            left: item.x * itemWidthPerColumn + gap * item.x,\n            width: item.w * itemWidthPerColumn + gap * Math.max(item.w - 1, 0),\n            height: item.h * rowHeightInPixels + gap * Math.max(item.h - 1, 0)\n        };\n    }\n    return renderItems;\n}\n\nfunction getGridHeight(layout: KtdGridLayout, rowHeight: number, gap: number): number {\n    return layout.reduce(\n        (acc, cur) => Math.max(acc, (cur.y + cur.h) * rowHeight + Math.max(cur.y + cur.h - 1, 0) * gap),\n        0\n    );\n}\n\n// eslint-disable-next-line\nexport function parseRenderItemToPixels(renderItem: KtdGridItemRenderData<number>): KtdGridItemRenderData<string> {\n    return {\n        id: renderItem.id,\n        top: `${renderItem.top}px`,\n        left: `${renderItem.left}px`,\n        width: `${renderItem.width}px`,\n        height: `${renderItem.height}px`\n    };\n}\n\n// eslint-disable-next-line\nexport function __gridItemGetRenderDataFactoryFunc(gridCmp: KtdGridComponent) {\n    return function (id: string) {\n        return parseRenderItemToPixels(gridCmp.getItemRenderData(id));\n    };\n}\n\nexport function ktdGridItemGetRenderDataFactoryFunc(gridCmp: KtdGridComponent): any {\n    // Workaround explained: https://github.com/ng-packagr/ng-packagr/issues/696#issuecomment-387114613\n    const resultFunc = __gridItemGetRenderDataFactoryFunc(gridCmp);\n    return resultFunc;\n}\n\nconst defaultBackgroundConfig: Required<Omit<KtdGridBackgroundCfg, 'show'>> = {\n    borderColor: '#ffa72678',\n    gapColor: 'transparent',\n    rowColor: 'transparent',\n    columnColor: 'transparent',\n    borderWidth: 1\n};\n\n@Component({\n    selector: 'buw-grid',\n    templateUrl: './grid.component.html',\n    styleUrls: ['./grid.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: GRID_ITEM_GET_RENDER_DATA_TOKEN,\n            useFactory: ktdGridItemGetRenderDataFactoryFunc,\n            deps: [KtdGridComponent]\n        }\n    ]\n})\nexport class KtdGridComponent implements OnChanges, AfterContentInit, AfterContentChecked, OnDestroy {\n    /** Query list of grid items that are being rendered. */\n    @ContentChildren(KtdGridItemComponent, { descendants: true }) _gridItems: QueryList<KtdGridItemComponent>;\n\n    /** Emits when layout change */\n    @Output() layoutUpdated: EventEmitter<KtdGridLayout> = new EventEmitter<KtdGridLayout>();\n\n    /** Emits when drag starts */\n    @Output() dragStarted: EventEmitter<KtdDragStart> = new EventEmitter<KtdDragStart>();\n\n    /** Emits when resize starts */\n    @Output() resizeStarted: EventEmitter<KtdResizeStart> = new EventEmitter<KtdResizeStart>();\n\n    /** Emits when drag ends */\n    @Output() dragEnded: EventEmitter<KtdDragEnd> = new EventEmitter<KtdDragEnd>();\n\n    /** Emits when resize ends */\n    @Output() resizeEnded: EventEmitter<KtdResizeEnd> = new EventEmitter<KtdResizeEnd>();\n\n    /** Emits when a grid item is being resized and its bounds have changed */\n    @Output() gridItemResize: EventEmitter<KtdGridItemResizeEvent> = new EventEmitter<KtdGridItemResizeEvent>();\n\n    /**\n     * Parent element that contains the scroll. If an string is provided it would search that element by id on the dom.\n     * If no data provided or null autoscroll is not performed.\n     */\n    @Input() scrollableParent: HTMLElement | Document | string | null = null;\n\n    /** Whether or not to update the internal layout when some dependent property change. */\n    @Input()\n    get compactOnPropsChange(): boolean {\n        return this._compactOnPropsChange;\n    }\n\n    set compactOnPropsChange(value: boolean) {\n        this._compactOnPropsChange = coerceBooleanProperty(value);\n    }\n\n    private _compactOnPropsChange = true;\n\n    /** If true, grid items won't change position when being dragged over. Handy when using no compaction */\n    @Input()\n    get preventCollision(): boolean {\n        return this._preventCollision;\n    }\n\n    set preventCollision(value: boolean) {\n        this._preventCollision = coerceBooleanProperty(value);\n    }\n\n    private _preventCollision = false;\n\n    /** Number of CSS pixels that would be scrolled on each 'tick' when auto scroll is performed. */\n    @Input()\n    get scrollSpeed(): number {\n        return this._scrollSpeed;\n    }\n\n    set scrollSpeed(value: number) {\n        this._scrollSpeed = coerceNumberProperty(value, 2);\n    }\n\n    private _scrollSpeed = 2;\n\n    /** Type of compaction that will be applied to the layout (vertical, horizontal or free). Defaults to 'vertical' */\n    @Input()\n    get compactType(): KtdGridCompactType {\n        return this._compactType;\n    }\n\n    set compactType(val: KtdGridCompactType) {\n        this._compactType = val;\n    }\n\n    private _compactType: KtdGridCompactType = 'vertical';\n\n    /**\n     * Row height as number or as 'fit'.\n     * If rowHeight is a number value, it means that each row would have those css pixels in height.\n     * if rowHeight is 'fit', it means that rows will fit in the height available. If 'fit' value is set, a 'height' should be also provided.\n     */\n    @Input()\n    get rowHeight(): number | 'fit' {\n        return this._rowHeight;\n    }\n\n    set rowHeight(val: number | 'fit') {\n        this._rowHeight = val === 'fit' ? val : Math.max(1, Math.round(coerceNumberProperty(val)));\n    }\n\n    private _rowHeight: number | 'fit' = 100;\n\n    /** Number of columns  */\n    @Input()\n    get cols(): number {\n        return this._cols;\n    }\n\n    set cols(val: number) {\n        this._cols = Math.max(1, Math.round(coerceNumberProperty(val)));\n    }\n\n    private _cols = 6;\n\n    /** Layout of the grid. Array of all the grid items with its 'id' and position on the grid. */\n    @Input()\n    get layout(): KtdGridLayout {\n        return this._layout;\n    }\n\n    set layout(layout: KtdGridLayout) {\n        /**\n         * Enhancement:\n         * Only set layout if it's reference has changed and use a boolean to track whenever recalculate the layout on ngOnChanges.\n         *\n         * Why:\n         * The normal use of this lib is having the variable layout in the outer component or in a store, assigning it whenever it changes and\n         * binded in the component with it's input [layout]. In this scenario, we would always calculate one unnecessary change on the layout when\n         * it is re-binded on the input.\n         */\n        this._layout = layout;\n    }\n\n    private _layout: KtdGridLayout;\n\n    /** Grid gap in css pixels */\n    @Input()\n    get gap(): number {\n        return this._gap;\n    }\n\n    set gap(val: number) {\n        this._gap = Math.max(coerceNumberProperty(val), 0);\n    }\n\n    private _gap = 0;\n\n    /**\n     * If height is a number, fixes the height of the grid to it, recommended when rowHeight = 'fit' is used.\n     * If height is null, height will be automatically set according to its inner grid items.\n     * Defaults to null.\n     * */\n    @Input()\n    get height(): number | null {\n        return this._height;\n    }\n\n    set height(val: number | null) {\n        this._height = typeof val === 'number' ? Math.max(val, 0) : null;\n    }\n\n    private _height: number | null = null;\n\n    @Input()\n    get backgroundConfig(): KtdGridBackgroundCfg | null {\n        return this._backgroundConfig;\n    }\n\n    set backgroundConfig(val: KtdGridBackgroundCfg | null) {\n        this._backgroundConfig = val;\n\n        // If there is background configuration, add main grid background class. Grid background class comes with opacity 0.\n        // It is done this way for adding opacity animation and to don't add any styles when grid background is null.\n        const classList = (this.elementRef.nativeElement as HTMLDivElement).classList;\n        this._backgroundConfig !== null\n            ? classList.add('buw-grid-background')\n            : classList.remove('buw-grid-background');\n\n        // Set background visibility\n        this.setGridBackgroundVisible(this._backgroundConfig?.show === 'always');\n    }\n\n    private _backgroundConfig: KtdGridBackgroundCfg | null = null;\n\n    private gridCurrentHeight: number;\n\n    get config(): KtdGridCfg {\n        return {\n            cols: this.cols,\n            rowHeight: this.rowHeight,\n            height: this.height,\n            layout: this.layout,\n            preventCollision: this.preventCollision,\n            gap: this.gap\n        };\n    }\n\n    /** Reference to the view of the placeholder element. */\n    private placeholderRef: EmbeddedViewRef<any> | null;\n\n    /** Element that is rendered as placeholder when a grid item is being dragged */\n    private placeholder: HTMLElement | null;\n\n    private _gridItemsRenderData: KtdDictionary<KtdGridItemRenderData<number>>;\n    private subscriptions: Subscription[] = [];\n\n    constructor(\n        private gridService: KtdGridService,\n        private elementRef: ElementRef,\n        private viewContainerRef: ViewContainerRef,\n        private renderer: Renderer2,\n        private ngZone: NgZone\n    ) {}\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (this.rowHeight === 'fit' && this.height == null) {\n            console.warn(`KtdGridComponent: The @Input() height should not be null when using rowHeight 'fit'`);\n        }\n\n        let needsCompactLayout = false;\n        let needsRecalculateRenderData = false;\n\n        // TODO: Does fist change need to be compacted by default?\n        // Compact layout whenever some dependent prop changes.\n        if (changes.compactType || changes.cols || changes.layout) {\n            needsCompactLayout = true;\n        }\n\n        // Check if wee need to recalculate rendering data.\n        if (needsCompactLayout || changes.rowHeight || changes.height || changes.gap || changes.backgroundConfig) {\n            needsRecalculateRenderData = true;\n        }\n\n        // Only compact layout if lib user has provided it. Lib users that want to save/store always the same layout  as it is represented (compacted)\n        // can use KtdCompactGrid utility and pre-compact the layout. This is the recommended behaviour for always having a the same layout on this component\n        // and the ones that uses it.\n        if (needsCompactLayout && this.compactOnPropsChange) {\n            this.compactLayout();\n        }\n\n        if (needsRecalculateRenderData) {\n            this.calculateRenderData();\n        }\n    }\n\n    ngAfterContentInit(): void {\n        this.initSubscriptions();\n    }\n\n    ngAfterContentChecked(): void {\n        this.render();\n    }\n\n    resize(): void {\n        this.calculateRenderData();\n        this.render();\n    }\n\n    ngOnDestroy(): void {\n        this.subscriptions.forEach((sub) => sub.unsubscribe());\n    }\n\n    compactLayout(): void {\n        this.layout = compact(this.layout, this.compactType, this.cols);\n    }\n\n    getItemsRenderData(): KtdDictionary<KtdGridItemRenderData<number>> {\n        return { ...this._gridItemsRenderData };\n    }\n\n    getItemRenderData(itemId: string): KtdGridItemRenderData<number> {\n        return this._gridItemsRenderData[itemId];\n    }\n\n    calculateRenderData(): void {\n        const clientRect = (this.elementRef.nativeElement as HTMLElement).getBoundingClientRect();\n        this.gridCurrentHeight =\n            this.height ??\n            (this.rowHeight === 'fit' ? clientRect.height : getGridHeight(this.layout, this.rowHeight, this.gap));\n        this._gridItemsRenderData = layoutToRenderItems(this.config, clientRect.width, this.gridCurrentHeight);\n\n        // Set Background CSS variables\n        this.setBackgroundCssVariables(getRowHeightInPixels(this.config, this.gridCurrentHeight));\n    }\n\n    render(): void {\n        this.renderer.setStyle(this.elementRef.nativeElement, 'height', `${this.gridCurrentHeight}px`);\n        this.updateGridItemsStyles();\n    }\n\n    private setBackgroundCssVariables(rowHeight: number): void {\n        const style = (this.elementRef.nativeElement as HTMLDivElement).style;\n\n        if (this._backgroundConfig) {\n            // structure\n            style.setProperty('--gap', this.gap + 'px');\n            style.setProperty('--row-height', rowHeight + 'px');\n            style.setProperty('--columns', `${this.cols}`);\n            style.setProperty(\n                '--border-width',\n                (this._backgroundConfig.borderWidth ?? defaultBackgroundConfig.borderWidth) + 'px'\n            );\n\n            // colors\n            style.setProperty(\n                '--border-color',\n                this._backgroundConfig.borderColor ?? defaultBackgroundConfig.borderColor\n            );\n            style.setProperty('--gap-color', this._backgroundConfig.gapColor ?? defaultBackgroundConfig.gapColor);\n            style.setProperty('--row-color', this._backgroundConfig.rowColor ?? defaultBackgroundConfig.rowColor);\n            style.setProperty(\n                '--column-color',\n                this._backgroundConfig.columnColor ?? defaultBackgroundConfig.columnColor\n            );\n        } else {\n            style.removeProperty('--gap');\n            style.removeProperty('--row-height');\n            style.removeProperty('--columns');\n            style.removeProperty('--border-width');\n            style.removeProperty('--border-color');\n            style.removeProperty('--gap-color');\n            style.removeProperty('--row-color');\n            style.removeProperty('--column-color');\n        }\n    }\n\n    private updateGridItemsStyles(): void {\n        this._gridItems.forEach((item) => {\n            const gridItemRenderData: KtdGridItemRenderData<number> | undefined = this._gridItemsRenderData[item.id];\n            if (gridItemRenderData == null) {\n                console.error(`Couldn't find the specified grid item for the id: ${item.id}`);\n            } else {\n                item.setStyles(parseRenderItemToPixels(gridItemRenderData));\n            }\n        });\n    }\n\n    private setGridBackgroundVisible(visible: boolean): void {\n        const classList = (this.elementRef.nativeElement as HTMLDivElement).classList;\n        visible ? classList.add('buw-grid-background-visible') : classList.remove('buw-grid-background-visible');\n    }\n\n    private initSubscriptions(): any {\n        this.subscriptions = [\n            this._gridItems.changes\n                .pipe(\n                    startWith(this._gridItems),\n                    switchMap((gridItems: QueryList<KtdGridItemComponent>) =>\n                        merge(\n                            ...gridItems.map((gridItem) =>\n                                gridItem.dragStart$.pipe(\n                                    map((event) => ({ event, gridItem, type: 'drag' as DragActionType }))\n                                )\n                            ),\n                            ...gridItems.map((gridItem) =>\n                                gridItem.resizeStart$.pipe(\n                                    map((event) => ({\n                                        event,\n                                        gridItem,\n                                        type: 'resize' as DragActionType\n                                    }))\n                                )\n                            )\n                        ).pipe(\n                            exhaustMap(({ event, gridItem, type }) => {\n                                // Emit drag or resize start events. Ensure that is start event is inside the zone.\n                                this.ngZone.run(() =>\n                                    (type === 'drag' ? this.dragStarted : this.resizeStarted).emit(\n                                        getDragResizeEventData(gridItem, this.layout)\n                                    )\n                                );\n\n                                this.setGridBackgroundVisible(\n                                    this._backgroundConfig?.show === 'whenDragging' ||\n                                        this._backgroundConfig?.show === 'always'\n                                );\n\n                                // Perform drag sequence\n                                return this.performDragSequence$(gridItem, event, type).pipe(\n                                    map((layout) => ({ layout, gridItem, type }))\n                                );\n                            })\n                        )\n                    )\n                )\n                .subscribe(({ layout, gridItem, type }) => {\n                    this.layout = layout;\n                    // Calculate new rendering data given the new layout.\n                    this.calculateRenderData();\n                    // Emit drag or resize end events.\n                    (type === 'drag' ? this.dragEnded : this.resizeEnded).emit(\n                        getDragResizeEventData(gridItem, layout)\n                    );\n                    // Notify that the layout has been updated.\n                    this.layoutUpdated.emit(layout);\n\n                    this.setGridBackgroundVisible(this._backgroundConfig?.show === 'always');\n                })\n        ];\n    }\n\n    /**\n     * Perform a general grid drag action, from start to end. A general grid drag action basically includes creating the placeholder element and adding\n     * some class animations. calcNewStateFunc needs to be provided in order to calculate the new state of the layout.\n     * @param gridItem that is been dragged\n     * @param pointerDownEvent event (mousedown or touchdown) where the user initiated the drag\n     * @param calcNewStateFunc function that return the new layout state and the drag element position\n     */\n    private performDragSequence$(\n        gridItem: KtdGridItemComponent,\n        pointerDownEvent: MouseEvent | TouchEvent,\n        type: DragActionType\n    ): Observable<KtdGridLayout> {\n        return new Observable<KtdGridLayout>((observer: Observer<KtdGridLayout>) => {\n            // Retrieve grid (parent) and gridItem (draggedElem) client rects.\n            const gridElemClientRect: KtdClientRect = getMutableClientRect(\n                this.elementRef.nativeElement as HTMLElement\n            );\n            const dragElemClientRect: KtdClientRect = getMutableClientRect(\n                gridItem.elementRef.nativeElement as HTMLElement\n            );\n\n            const scrollableParent =\n                typeof this.scrollableParent === 'string'\n                    ? document.getElementById(this.scrollableParent)\n                    : this.scrollableParent;\n\n            this.renderer.addClass(gridItem.elementRef.nativeElement, 'no-transitions');\n            this.renderer.addClass(gridItem.elementRef.nativeElement, 'buw-grid-item-dragging');\n\n            const placeholderClientRect: KtdClientRect = {\n                ...dragElemClientRect,\n                left: dragElemClientRect.left - gridElemClientRect.left,\n                top: dragElemClientRect.top - gridElemClientRect.top\n            };\n            this.createPlaceholderElement(placeholderClientRect, gridItem.placeholder);\n\n            let newLayout: KtdGridLayoutItem[];\n\n            // TODO (enhancement): consider move this 'side effect' observable inside the main drag loop.\n            //  - Pros are that we would not repeat subscriptions and takeUntil would shut down observables at the same time.\n            //  - Cons are that moving this functionality as a side effect inside the main drag loop would be confusing.\n            const scrollSubscription = this.ngZone.runOutsideAngular(() =>\n                (!scrollableParent\n                    ? NEVER\n                    : this.gridService.mouseOrTouchMove$(document).pipe(\n                          map((event) => ({\n                              pointerX: ktdPointerClientX(event),\n                              pointerY: ktdPointerClientY(event)\n                          })),\n                          ktdScrollIfNearElementClientRect$(scrollableParent, { scrollStep: this.scrollSpeed })\n                      )\n                )\n                    .pipe(takeUntil(ktdPointerUp(document)))\n                    .subscribe()\n            );\n\n            /**\n             * Main subscription, it listens for 'pointer move' and 'scroll' events and recalculates the layout on each emission\n             */\n            const subscription = this.ngZone.runOutsideAngular(() =>\n                merge(\n                    combineLatest([\n                        this.gridService.mouseOrTouchMove$(document),\n                        ...(!scrollableParent\n                            ? [of({ top: 0, left: 0 })]\n                            : [\n                                  ktdGetScrollTotalRelativeDifference$(scrollableParent).pipe(\n                                      startWith({ top: 0, left: 0 }) // Force first emission to allow CombineLatest to emit even no scroll event has occurred\n                                  )\n                              ])\n                    ])\n                )\n                    .pipe(takeUntil(ktdPointerUp(document)))\n                    .subscribe(\n                        ([pointerDragEvent, scrollDifference]) =>\n                            //    : [MouseEvent | TouchEvent | PointerEvent{ top: number; left: number }]\n                            {\n                                pointerDragEvent.preventDefault();\n\n                                /**\n                                 * Set the new layout to be the layout in which the calcNewStateFunc would be executed.\n                                 * NOTE: using the mutated layout is the way to go by 'react-grid-layout' utils. If we don't use the previous layout,\n                                 * some utilities from 'react-grid-layout' would not work as expected.\n                                 */\n                                const currentLayout: KtdGridLayout = newLayout || this.layout;\n\n                                // Get the correct newStateFunc depending on if we are dragging or resizing\n                                const calcNewStateFunc = type === 'drag' ? ktdGridItemDragging : ktdGridItemResizing;\n\n                                const { layout, draggedItemPos } = calcNewStateFunc(\n                                    gridItem,\n                                    {\n                                        layout: currentLayout,\n                                        rowHeight: this.rowHeight,\n                                        height: this.height,\n                                        cols: this.cols,\n                                        preventCollision: this.preventCollision,\n                                        gap: this.gap\n                                    },\n                                    this.compactType,\n                                    {\n                                        pointerDownEvent,\n                                        pointerDragEvent,\n                                        gridElemClientRect,\n                                        dragElemClientRect,\n                                        scrollDifference\n                                    }\n                                );\n                                newLayout = layout;\n\n                                this.gridCurrentHeight =\n                                    this.height ??\n                                    (this.rowHeight === 'fit'\n                                        ? gridElemClientRect.height\n                                        : getGridHeight(newLayout, this.rowHeight, this.gap));\n\n                                this._gridItemsRenderData = layoutToRenderItems(\n                                    {\n                                        cols: this.cols,\n                                        rowHeight: this.rowHeight,\n                                        height: this.height,\n                                        layout: newLayout,\n                                        preventCollision: this.preventCollision,\n                                        gap: this.gap\n                                    },\n                                    gridElemClientRect.width,\n                                    gridElemClientRect.height\n                                );\n\n                                const newGridItemRenderData = { ...this._gridItemsRenderData[gridItem.id] };\n                                const placeholderStyles = parseRenderItemToPixels(newGridItemRenderData);\n\n                                // Put the real final position to the placeholder element\n                                this.placeholder!.style.width = placeholderStyles.width;\n                                this.placeholder!.style.height = placeholderStyles.height;\n                                this.placeholder!.style.transform = `translateX(${placeholderStyles.left}) translateY(${placeholderStyles.top})`;\n\n                                // modify the position of the dragged item to be the once we want (for example the mouse position or whatever)\n                                this._gridItemsRenderData[gridItem.id] = {\n                                    ...draggedItemPos,\n                                    id: this._gridItemsRenderData[gridItem.id].id\n                                };\n\n                                this.setBackgroundCssVariables(\n                                    this.rowHeight === 'fit'\n                                        ? ktdGetGridItemRowHeight(newLayout, gridElemClientRect.height, this.gap)\n                                        : this.rowHeight\n                                );\n\n                                this.render();\n\n                                // If we are performing a resize, and bounds have changed, emit event.\n                                // NOTE: Only emit on resize for now. Use case for normal drag is not justified for now. Emitting on resize is,\n                                // since we may want to re-render the grid item or the placeholder in order to fit the new bounds.\n                                if (type === 'resize') {\n                                    const prevGridItem = currentLayout.find((item) => item.id === gridItem.id)!;\n                                    const newGridItem = newLayout.find((item) => item.id === gridItem.id)!;\n                                    // Check if item resized has changed, if so, emit resize change event\n                                    if (!ktdGridItemLayoutItemAreEqual(prevGridItem, newGridItem)) {\n                                        this.gridItemResize.emit({\n                                            width: newGridItemRenderData.width,\n                                            height: newGridItemRenderData.height,\n                                            gridItemRef: getDragResizeEventData(gridItem, newLayout).gridItemRef\n                                        });\n                                    }\n                                }\n                            },\n                        (error) => observer.error(error),\n                        () => {\n                            this.ngZone.run(() => {\n                                // Remove drag classes\n                                this.renderer.removeClass(gridItem.elementRef.nativeElement, 'no-transitions');\n                                this.renderer.removeClass(gridItem.elementRef.nativeElement, 'buw-grid-item-dragging');\n\n                                this.addGridItemAnimatingClass(gridItem).subscribe();\n                                // Consider destroying the placeholder after the animation has finished.\n                                this.destroyPlaceholder();\n\n                                if (newLayout) {\n                                    // TODO: newLayout should already be pruned. If not, it should have type Layout, not KtdGridLayout as it is now.\n                                    // Prune react-grid-layout compact extra properties.\n                                    observer.next(\n                                        newLayout.map((item) => ({\n                                            id: item.id,\n                                            x: item.x,\n                                            y: item.y,\n                                            w: item.w,\n                                            h: item.h,\n                                            minW: item.minW,\n                                            minH: item.minH,\n                                            maxW: item.maxW,\n                                            maxH: item.maxH\n                                        })) as KtdGridLayout\n                                    );\n                                } else {\n                                    // TODO: Need we really to emit if there is no layout change but drag started and ended?\n                                    observer.next(this.layout);\n                                }\n\n                                observer.complete();\n                            });\n                        }\n                    )\n            );\n\n            return () => {\n                scrollSubscription.unsubscribe();\n                subscription.unsubscribe();\n            };\n        });\n    }\n\n    /**\n     * It adds the `buw-grid-item-animating` class and removes it when the animated transition is complete.\n     * This function is meant to be executed when the drag has ended.\n     * @param gridItem that has been dragged\n     */\n    private addGridItemAnimatingClass(gridItem: KtdGridItemComponent): Observable<undefined> {\n        return new Observable((observer) => {\n            const duration = getTransformTransitionDurationInMs(gridItem.elementRef.nativeElement);\n\n            if (duration === 0) {\n                observer.next();\n                observer.complete();\n                return;\n            }\n\n            this.renderer.addClass(gridItem.elementRef.nativeElement, 'buw-grid-item-animating');\n            const handler = ((event: TransitionEvent) => {\n                if (\n                    !event ||\n                    (event.target === gridItem.elementRef.nativeElement && event.propertyName === 'transform')\n                ) {\n                    this.renderer.removeClass(gridItem.elementRef.nativeElement, 'buw-grid-item-animating');\n                    removeEventListener();\n                    clearTimeout(timeout);\n                    observer.next();\n                    observer.complete();\n                }\n            }) as EventListener;\n\n            // If a transition is short enough, the browser might not fire the `transitionend` event.\n            // Since we know how long it's supposed to take, add a timeout with a 50% buffer that'll\n            // fire if the transition hasn't completed when it was supposed to.\n            const timeout = setTimeout(handler, duration * 1.5);\n            const removeEventListener = this.renderer.listen(\n                gridItem.elementRef.nativeElement,\n                'transitionend',\n                handler\n            );\n        });\n    }\n\n    /** Creates placeholder element */\n    private createPlaceholderElement(clientRect: KtdClientRect, gridItemPlaceholder?: KtdGridItemPlaceholder): void {\n        this.placeholder = this.renderer.createElement('div');\n        this.placeholder!.style.width = `${clientRect.width}px`;\n        this.placeholder!.style.height = `${clientRect.height}px`;\n        this.placeholder!.style.transform = `translateX(${clientRect.left}px) translateY(${clientRect.top}px)`;\n        this.placeholder!.classList.add('buw-grid-item-placeholder');\n        this.renderer.appendChild(this.elementRef.nativeElement, this.placeholder);\n\n        // Create and append custom placeholder if provided.\n        // Important: Append it after creating & appending the container placeholder. This way we ensure parent bounds are set when creating the embeddedView.\n        if (gridItemPlaceholder) {\n            this.placeholderRef = this.viewContainerRef.createEmbeddedView(\n                gridItemPlaceholder.templateRef,\n                gridItemPlaceholder.data\n            );\n            this.placeholderRef.rootNodes.forEach((node) => this.placeholder!.appendChild(node));\n            this.placeholderRef.detectChanges();\n        } else {\n            this.placeholder!.classList.add('buw-grid-item-placeholder-default');\n        }\n    }\n\n    /** Destroys the placeholder element and its ViewRef. */\n    private destroyPlaceholder(): void {\n        this.placeholder?.remove();\n        this.placeholderRef?.destroy();\n        this.placeholder = this.placeholderRef = null!;\n    }\n\n    static ngAcceptInputType_cols: NumberInput;\n    static ngAcceptInputType_rowHeight: NumberInput;\n    static ngAcceptInputType_scrollSpeed: NumberInput;\n    static ngAcceptInputType_compactOnPropsChange: BooleanInput;\n    static ngAcceptInputType_preventCollision: BooleanInput;\n}\n\n","<ng-content></ng-content>"]}