barsa-user-workspace 0.0.0-watch

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

@@ -0,0 +1,196 @@
+import { ChangeDetectionStrategy, Component, ContentChild, ContentChildren, ElementRef, Inject, Input, ViewChild } from '@angular/core';
+import { BehaviorSubject, NEVER, Subject, iif, merge } from 'rxjs';
+import { exhaustMap, filter, map, startWith, switchMap, take, takeUntil, tap } from 'rxjs/operators';
+import { coerceBooleanProperty } from '../coercion/boolean-property';
+import { coerceNumberProperty } from '../coercion/number-property';
+import { KTD_GRID_DRAG_HANDLE } from '../directives/drag-handle';
+import { KTD_GRID_ITEM_PLACEHOLDER } from '../directives/placeholder';
+import { KTD_GRID_RESIZE_HANDLE } from '../directives/resize-handle';
+import { GRID_ITEM_GET_RENDER_DATA_TOKEN } from '../grid.definitions';
+import { ktdOutsideZone } from '../utils/operators';
+import { ktdIsMouseEventOrMousePointerEvent, ktdPointerClient, ktdPointerDown, ktdPointerUp } from '../utils/pointer.utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../grid.service";
+export class KtdGridItemComponent {
+    /** Id of the grid item. This property is strictly compulsory. */
+    get id() {
+        return this._id;
+    }
+    set id(val) {
+        this._id = val;
+    }
+    /** Minimum amount of pixels that the user should move before it starts the drag sequence. */
+    get dragStartThreshold() {
+        return this._dragStartThreshold;
+    }
+    set dragStartThreshold(val) {
+        this._dragStartThreshold = coerceNumberProperty(val);
+    }
+    /** Whether the item is draggable or not. Defaults to true. Does not affect manual dragging using the startDragManually method. */
+    get draggable() {
+        return this._draggable;
+    }
+    set draggable(val) {
+        this._draggable = coerceBooleanProperty(val);
+        this._draggable$.next(this._draggable);
+    }
+    /** Whether the item is resizable or not. Defaults to true. */
+    get resizable() {
+        return this._resizable;
+    }
+    set resizable(val) {
+        this._resizable = coerceBooleanProperty(val);
+        this._resizable$.next(this._resizable);
+    }
+    constructor(elementRef, gridService, renderer, ngZone, getItemRenderData) {
+        this.elementRef = elementRef;
+        this.gridService = gridService;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        this.getItemRenderData = getItemRenderData;
+        /** CSS transition style. Note that for more performance is preferable only make transition on transform property. */
+        this.transition = 'transform 500ms ease, width 500ms ease, height 500ms ease';
+        this._dragStartThreshold = 0;
+        this._draggable = true;
+        this._draggable$ = new BehaviorSubject(this._draggable);
+        this._manualDragEvents$ = new Subject();
+        this._resizable = true;
+        this._resizable$ = new BehaviorSubject(this._resizable);
+        this.dragStartSubject = new Subject();
+        this.resizeStartSubject = new Subject();
+        this.subscriptions = [];
+        this.dragStart$ = this.dragStartSubject.asObservable();
+        this.resizeStart$ = this.resizeStartSubject.asObservable();
+    }
+    ngOnInit() {
+        const gridItemRenderData = this.getItemRenderData(this.id);
+        this.setStyles(gridItemRenderData);
+    }
+    ngAfterContentInit() {
+        this.subscriptions.push(this._dragStart$().subscribe(this.dragStartSubject), this._resizeStart$().subscribe(this.resizeStartSubject));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+    /**
+     * To manually start dragging, route the desired pointer events to this method.
+     * Dragging initiated by this method will work regardless of the value of the draggable Input.
+     * It is the caller's responsibility to call this method with only the events that are desired to cause a drag.
+     * For example, if you only want left clicks to cause a drag, it is your responsibility to filter out other mouse button events.
+     * @param startEvent The pointer event that should initiate the drag.
+     */
+    startDragManually(startEvent) {
+        this._manualDragEvents$.next(startEvent);
+    }
+    setStyles({ top, left, width, height }) {
+        // transform is 6x times faster than top/left
+        this.renderer.setStyle(this.elementRef.nativeElement, 'transform', `translateX(${left}) translateY(${top})`);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'display', `block`);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'transition', this.transition);
+        if (width != null) {
+            this.renderer.setStyle(this.elementRef.nativeElement, 'width', width);
+        }
+        if (height != null) {
+            this.renderer.setStyle(this.elementRef.nativeElement, 'height', height);
+        }
+    }
+    _dragStart$() {
+        return merge(this._manualDragEvents$, this._draggable$.pipe(switchMap((draggable) => {
+            if (!draggable) {
+                return NEVER;
+            }
+            return this._dragHandles.changes.pipe(startWith(this._dragHandles), switchMap((dragHandles) => iif(() => dragHandles.length > 0, merge(...dragHandles
+                .toArray()
+                .map((dragHandle) => ktdPointerDown(dragHandle.element.nativeElement))), ktdPointerDown(this.elementRef.nativeElement))));
+        }))).pipe(exhaustMap((startEvent) => {
+            // If the event started from an element with the native HTML drag&drop, it'll interfere
+            // with our own dragging (e.g. `img` tags do it by default). Prevent the default action
+            // to stop it from happening. Note that preventing on `dragstart` also seems to work, but
+            // it's flaky and it fails if the user drags it away quickly. Also note that we only want
+            // to do this for `mousedown` and `pointerdown` since doing the same for `touchstart` will
+            // stop any `click` events from firing on touch devices.
+            if (ktdIsMouseEventOrMousePointerEvent(startEvent)) {
+                startEvent.preventDefault();
+            }
+            const startPointer = ktdPointerClient(startEvent);
+            return this.gridService.mouseOrTouchMove$(document).pipe(takeUntil(ktdPointerUp(document)), ktdOutsideZone(this.ngZone), filter((moveEvent) => {
+                moveEvent.preventDefault();
+                const movePointer = ktdPointerClient(moveEvent);
+                const distanceX = Math.abs(startPointer.clientX - movePointer.clientX);
+                const distanceY = Math.abs(startPointer.clientY - movePointer.clientY);
+                // When this conditions returns true mean that we are over threshold.
+                return distanceX + distanceY >= this.dragStartThreshold;
+            }), take(1), 
+            // Return the original start event
+            map(() => startEvent));
+        }));
+    }
+    _resizeStart$() {
+        return this._resizable$.pipe(switchMap((resizable) => {
+            if (!resizable) {
+                // Side effect to hide the resizeElem if resize is disabled.
+                this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'none');
+                return NEVER;
+            }
+            else {
+                return this._resizeHandles.changes.pipe(startWith(this._resizeHandles), switchMap((resizeHandles) => {
+                    if (resizeHandles.length > 0) {
+                        // Side effect to hide the resizeElem if there are resize handles.
+                        this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'none');
+                        return merge(...resizeHandles
+                            .toArray()
+                            .map((resizeHandle) => ktdPointerDown(resizeHandle.element.nativeElement)));
+                    }
+                    else {
+                        this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'block');
+                        return ktdPointerDown(this.resizeElem.nativeElement);
+                    }
+                }), tap((startEvent) => {
+                    if (ktdIsMouseEventOrMousePointerEvent(startEvent)) {
+                        startEvent.preventDefault();
+                    }
+                }));
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridItemComponent, deps: [{ token: i0.ElementRef }, { token: i1.KtdGridService }, { token: i0.Renderer2 }, { token: i0.NgZone }, { token: GRID_ITEM_GET_RENDER_DATA_TOKEN }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: KtdGridItemComponent, selector: "buw-grid-item", inputs: { minW: "minW", minH: "minH", maxW: "maxW", maxH: "maxH", transition: "transition", id: "id", dragStartThreshold: "dragStartThreshold", draggable: "draggable", resizable: "resizable" }, queries: [{ propertyName: "placeholder", first: true, predicate: KTD_GRID_ITEM_PLACEHOLDER, descendants: true }, { propertyName: "_dragHandles", predicate: KTD_GRID_DRAG_HANDLE, descendants: true }, { propertyName: "_resizeHandles", predicate: KTD_GRID_RESIZE_HANDLE, descendants: true }], viewQueries: [{ propertyName: "resizeElem", first: true, predicate: ["resizeElem"], descendants: true, read: ElementRef, static: true }], ngImport: i0, template: "<ng-content></ng-content>\n<div #resizeElem class=\"grid-item-resize-icon\"></div>", styles: [":host{display:none;position:absolute;z-index:1;overflow:hidden;touch-action:none;border:1px dashed #000}:host div{position:absolute;-webkit-user-select:none;user-select:none;z-index:10}:host div.grid-item-resize-icon{cursor:se-resize;width:20px;height:20px;bottom:0;right:0;color:inherit}:host div.grid-item-resize-icon:after{content:\"\";position:absolute;right:3px;bottom:3px;width:5px;height:5px;border-right:2px solid;border-bottom:2px solid}.display-none{display:none!important}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'buw-grid-item', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>\n<div #resizeElem class=\"grid-item-resize-icon\"></div>", styles: [":host{display:none;position:absolute;z-index:1;overflow:hidden;touch-action:none;border:1px dashed #000}:host div{position:absolute;-webkit-user-select:none;user-select:none;z-index:10}:host div.grid-item-resize-icon{cursor:se-resize;width:20px;height:20px;bottom:0;right:0;color:inherit}:host div.grid-item-resize-icon:after{content:\"\";position:absolute;right:3px;bottom:3px;width:5px;height:5px;border-right:2px solid;border-bottom:2px solid}.display-none{display:none!important}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.KtdGridService }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GRID_ITEM_GET_RENDER_DATA_TOKEN]
+                }] }], propDecorators: { _dragHandles: [{
+                type: ContentChildren,
+                args: [KTD_GRID_DRAG_HANDLE, { descendants: true }]
+            }], _resizeHandles: [{
+                type: ContentChildren,
+                args: [KTD_GRID_RESIZE_HANDLE, { descendants: true }]
+            }], resizeElem: [{
+                type: ViewChild,
+                args: ['resizeElem', { static: true, read: ElementRef }]
+            }], placeholder: [{
+                type: ContentChild,
+                args: [KTD_GRID_ITEM_PLACEHOLDER]
+            }], minW: [{
+                type: Input
+            }], minH: [{
+                type: Input
+            }], maxW: [{
+                type: Input
+            }], maxH: [{
+                type: Input
+            }], transition: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], dragStartThreshold: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], resizable: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-item.component.js","sourceRoot":"","sources":["../../../../../projects/barsa-user-workspace/src/lib/grid-item/grid-item.component.ts","../../../../../projects/barsa-user-workspace/src/lib/grid-item/grid-item.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    AfterContentInit,\n    ChangeDetectionStrategy,\n    Component,\n    ContentChild,\n    ContentChildren,\n    ElementRef,\n    Inject,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    QueryList,\n    Renderer2,\n    ViewChild\n} from '@angular/core';\nimport { BehaviorSubject, NEVER, Observable, Subject, Subscription, iif, merge } from 'rxjs';\nimport { exhaustMap, filter, map, startWith, switchMap, take, takeUntil, tap } from 'rxjs/operators';\nimport { BooleanInput, coerceBooleanProperty } from '../coercion/boolean-property';\nimport { NumberInput, coerceNumberProperty } from '../coercion/number-property';\nimport { KTD_GRID_DRAG_HANDLE, KtdGridDragHandle } from '../directives/drag-handle';\nimport { KTD_GRID_ITEM_PLACEHOLDER, KtdGridItemPlaceholder } from '../directives/placeholder';\nimport { KTD_GRID_RESIZE_HANDLE, KtdGridResizeHandle } from '../directives/resize-handle';\nimport { GRID_ITEM_GET_RENDER_DATA_TOKEN, KtdGridItemRenderDataTokenType } from '../grid.definitions';\nimport { KtdGridService } from '../grid.service';\nimport { ktdOutsideZone } from '../utils/operators';\nimport {\n    ktdIsMouseEventOrMousePointerEvent,\n    ktdPointerClient,\n    ktdPointerDown,\n    ktdPointerUp\n} from '../utils/pointer.utils';\n\n@Component({\n    selector: 'buw-grid-item',\n    templateUrl: './grid-item.component.html',\n    styleUrls: ['./grid-item.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class KtdGridItemComponent implements OnInit, OnDestroy, AfterContentInit {\n    /** Elements that can be used to drag the grid item. */\n    @ContentChildren(KTD_GRID_DRAG_HANDLE, { descendants: true }) _dragHandles: QueryList<KtdGridDragHandle>;\n    @ContentChildren(KTD_GRID_RESIZE_HANDLE, { descendants: true }) _resizeHandles: QueryList<KtdGridResizeHandle>;\n    @ViewChild('resizeElem', { static: true, read: ElementRef }) resizeElem: ElementRef;\n\n    /** Template ref for placeholder */\n    @ContentChild(KTD_GRID_ITEM_PLACEHOLDER) placeholder: KtdGridItemPlaceholder;\n\n    /** Min and max size input properties. Any of these would 'override' the min/max values specified in the layout. */\n    @Input() minW?: number;\n    @Input() minH?: number;\n    @Input() maxW?: number;\n    @Input() maxH?: number;\n\n    /** CSS transition style. Note that for more performance is preferable only make transition on transform property. */\n    @Input() transition = 'transform 500ms ease, width 500ms ease, height 500ms ease';\n\n    dragStart$: Observable<MouseEvent | TouchEvent>;\n    resizeStart$: Observable<MouseEvent | TouchEvent>;\n\n    /** Id of the grid item. This property is strictly compulsory. */\n    @Input()\n    get id(): string {\n        return this._id;\n    }\n\n    set id(val: string) {\n        this._id = val;\n    }\n\n    private _id: string;\n\n    /** Minimum amount of pixels that the user should move before it starts the drag sequence. */\n    @Input()\n    get dragStartThreshold(): number {\n        return this._dragStartThreshold;\n    }\n\n    set dragStartThreshold(val: number) {\n        this._dragStartThreshold = coerceNumberProperty(val);\n    }\n\n    private _dragStartThreshold = 0;\n\n    /** Whether the item is draggable or not. Defaults to true. Does not affect manual dragging using the startDragManually method. */\n    @Input()\n    get draggable(): boolean {\n        return this._draggable;\n    }\n\n    set draggable(val: boolean) {\n        this._draggable = coerceBooleanProperty(val);\n        this._draggable$.next(this._draggable);\n    }\n\n    private _draggable = true;\n    private _draggable$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(this._draggable);\n\n    private _manualDragEvents$: Subject<MouseEvent | TouchEvent> = new Subject<MouseEvent | TouchEvent>();\n\n    /** Whether the item is resizable or not. Defaults to true. */\n    @Input()\n    get resizable(): boolean {\n        return this._resizable;\n    }\n\n    set resizable(val: boolean) {\n        this._resizable = coerceBooleanProperty(val);\n        this._resizable$.next(this._resizable);\n    }\n\n    private _resizable = true;\n    private _resizable$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(this._resizable);\n\n    private dragStartSubject: Subject<MouseEvent | TouchEvent> = new Subject<MouseEvent | TouchEvent>();\n    private resizeStartSubject: Subject<MouseEvent | TouchEvent> = new Subject<MouseEvent | TouchEvent>();\n\n    private subscriptions: Subscription[] = [];\n\n    constructor(\n        public elementRef: ElementRef,\n        private gridService: KtdGridService,\n        private renderer: Renderer2,\n        private ngZone: NgZone,\n        @Inject(GRID_ITEM_GET_RENDER_DATA_TOKEN) private getItemRenderData: KtdGridItemRenderDataTokenType\n    ) {\n        this.dragStart$ = this.dragStartSubject.asObservable();\n        this.resizeStart$ = this.resizeStartSubject.asObservable();\n    }\n\n    ngOnInit(): void {\n        const gridItemRenderData = this.getItemRenderData(this.id)!;\n        this.setStyles(gridItemRenderData);\n    }\n\n    ngAfterContentInit(): void {\n        this.subscriptions.push(\n            this._dragStart$().subscribe(this.dragStartSubject),\n            this._resizeStart$().subscribe(this.resizeStartSubject)\n        );\n    }\n\n    ngOnDestroy(): void {\n        this.subscriptions.forEach((sub) => sub.unsubscribe());\n    }\n\n    /**\n     * To manually start dragging, route the desired pointer events to this method.\n     * Dragging initiated by this method will work regardless of the value of the draggable Input.\n     * It is the caller's responsibility to call this method with only the events that are desired to cause a drag.\n     * For example, if you only want left clicks to cause a drag, it is your responsibility to filter out other mouse button events.\n     * @param startEvent The pointer event that should initiate the drag.\n     */\n    startDragManually(startEvent: MouseEvent | TouchEvent): void {\n        this._manualDragEvents$.next(startEvent);\n    }\n\n    setStyles({ top, left, width, height }: { top: string; left: string; width?: string; height?: string }): void {\n        // transform is 6x times faster than top/left\n        this.renderer.setStyle(this.elementRef.nativeElement, 'transform', `translateX(${left}) translateY(${top})`);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'display', `block`);\n        this.renderer.setStyle(this.elementRef.nativeElement, 'transition', this.transition);\n        if (width != null) {\n            this.renderer.setStyle(this.elementRef.nativeElement, 'width', width);\n        }\n        if (height != null) {\n            this.renderer.setStyle(this.elementRef.nativeElement, 'height', height);\n        }\n    }\n\n    private _dragStart$(): Observable<MouseEvent | TouchEvent> {\n        return merge(\n            this._manualDragEvents$,\n            this._draggable$.pipe(\n                switchMap((draggable) => {\n                    if (!draggable) {\n                        return NEVER;\n                    }\n                    return this._dragHandles.changes.pipe(\n                        startWith(this._dragHandles),\n                        switchMap((dragHandles: QueryList<KtdGridDragHandle>) => iif(\n                                () => dragHandles.length > 0,\n                                merge(\n                                    ...dragHandles\n                                        .toArray()\n                                        .map((dragHandle) => ktdPointerDown(dragHandle.element.nativeElement))\n                                ),\n                                ktdPointerDown(this.elementRef.nativeElement)\n                            ))\n                    );\n                })\n            )\n        ).pipe(\n            exhaustMap((startEvent) => {\n                // If the event started from an element with the native HTML drag&drop, it'll interfere\n                // with our own dragging (e.g. `img` tags do it by default). Prevent the default action\n                // to stop it from happening. Note that preventing on `dragstart` also seems to work, but\n                // it's flaky and it fails if the user drags it away quickly. Also note that we only want\n                // to do this for `mousedown` and `pointerdown` since doing the same for `touchstart` will\n                // stop any `click` events from firing on touch devices.\n                if (ktdIsMouseEventOrMousePointerEvent(startEvent)) {\n                    startEvent.preventDefault();\n                }\n\n                const startPointer = ktdPointerClient(startEvent);\n                return this.gridService.mouseOrTouchMove$(document).pipe(\n                    takeUntil(ktdPointerUp(document)),\n                    ktdOutsideZone(this.ngZone),\n                    filter((moveEvent) => {\n                        moveEvent.preventDefault();\n                        const movePointer = ktdPointerClient(moveEvent);\n                        const distanceX = Math.abs(startPointer.clientX - movePointer.clientX);\n                        const distanceY = Math.abs(startPointer.clientY - movePointer.clientY);\n                        // When this conditions returns true mean that we are over threshold.\n                        return distanceX + distanceY >= this.dragStartThreshold;\n                    }),\n                    take(1),\n                    // Return the original start event\n                    map(() => startEvent)\n                );\n            })\n        );\n    }\n\n    private _resizeStart$(): Observable<MouseEvent | TouchEvent> {\n        return this._resizable$.pipe(\n            switchMap((resizable) => {\n                if (!resizable) {\n                    // Side effect to hide the resizeElem if resize is disabled.\n                    this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'none');\n                    return NEVER;\n                } else {\n                    return this._resizeHandles.changes.pipe(\n                        startWith(this._resizeHandles),\n                        switchMap((resizeHandles: QueryList<KtdGridResizeHandle>) => {\n                            if (resizeHandles.length > 0) {\n                                // Side effect to hide the resizeElem if there are resize handles.\n                                this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'none');\n                                return merge(\n                                    ...resizeHandles\n                                        .toArray()\n                                        .map((resizeHandle) => ktdPointerDown(resizeHandle.element.nativeElement))\n                                );\n                            } else {\n                                this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'block');\n                                return ktdPointerDown(this.resizeElem.nativeElement);\n                            }\n                        }),\n                        tap((startEvent) => {\n                            if (ktdIsMouseEventOrMousePointerEvent(startEvent)) {\n                                startEvent.preventDefault();\n                            }\n                        })\n                    );\n                }\n            })\n        );\n    }\n\n    static ngAcceptInputType_minW: NumberInput;\n    static ngAcceptInputType_minH: NumberInput;\n    static ngAcceptInputType_maxW: NumberInput;\n    static ngAcceptInputType_maxH: NumberInput;\n    static ngAcceptInputType_draggable: BooleanInput;\n    static ngAcceptInputType_resizable: BooleanInput;\n    static ngAcceptInputType_dragStartThreshold: NumberInput;\n}\n\n","<ng-content></ng-content>\n<div #resizeElem class=\"grid-item-resize-icon\"></div>"]}

package/esm2022/lib/grid.definitions.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const GRID_ITEM_GET_RENDER_DATA_TOKEN = new InjectionToken('GRID_ITEM_GET_RENDER_DATA_TOKEN');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/grid.service.mjs

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { ktdNormalizePassiveListenerOptions } from './utils/passive-listeners';
+import { fromEvent, iif, Subject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { ktdIsMobileOrTablet, ktdSupportsPointerEvents } from './utils/pointer.utils';
+import * as i0 from "@angular/core";
+/** Event options that can be used to bind an active, capturing event. */
+const activeCapturingEventOptions = ktdNormalizePassiveListenerOptions({
+    passive: false,
+    capture: true
+});
+export class KtdGridService {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this.touchMoveSubject = new Subject();
+        this.touchMove$ = this.touchMoveSubject.asObservable();
+        this.registerTouchMoveSubscription();
+    }
+    ngOnDestroy() {
+        this.touchMoveSubscription.unsubscribe();
+    }
+    mouseOrTouchMove$(element) {
+        if (!ktdSupportsPointerEvents()) {
+            return iif(() => ktdIsMobileOrTablet(), this.touchMove$, fromEvent(element, 'mousemove', activeCapturingEventOptions)
+            // TODO: Fix rxjs typings, boolean should be a good param too.
+            );
+        }
+        return fromEvent(element, 'pointermove', activeCapturingEventOptions);
+    }
+    registerTouchMoveSubscription() {
+        // The `touchmove` event gets bound once, ahead of time, because WebKit
+        // won't preventDefault on a dynamically-added `touchmove` listener.
+        // See https://bugs.webkit.org/show_bug.cgi?id=184250.
+        this.touchMoveSubscription = this.ngZone.runOutsideAngular(() => 
+        // The event handler has to be explicitly active,
+        // because newer browsers make it passive by default.
+        fromEvent(document, 'touchmove', activeCapturingEventOptions)
+            // TODO: Fix rxjs typings, boolean should be a good param too.
+            .pipe(filter((touchEvent) => touchEvent.touches.length === 1))
+            .subscribe((touchEvent) => this.touchMoveSubject.next(touchEvent)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: KtdGridService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/layout-container/layout-container.component.mjs

@@ -0,0 +1,213 @@
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Inject, ViewChild, Input } from '@angular/core';
+import { BaseComponent } from 'barsa-novin-ray-core';
+import { debounceTime, filter, fromEvent, merge } from 'rxjs';
+import { KtdGridComponent } from '../grid/grid.component';
+import { ktdGridCompact, ktdTrackById } from '../utils/grid.utils';
+import { ktdArrayRemoveItem } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "barsa-novin-ray-core";
+import * as i3 from "../grid/grid.component";
+import * as i4 from "../grid-item/grid-item.component";
+import * as i5 from "../directives/placeholder";
+export class LayoutContainerComponent extends BaseComponent {
+    constructor(ngZone, elementRef, document) {
+        // this.ngZone.onUnstable.subscribe(() => console.log('UnStable'));
+        super();
+        this.ngZone = ngZone;
+        this.elementRef = elementRef;
+        this.document = document;
+        // @Input() layout: KtdGridLayout = [{ id: '0', x: 5, y: 0, w: 2, h: 3 }];
+        this.layout = [];
+        this.moDataList = [];
+        this.trackById = ktdTrackById;
+        this.cols = 12;
+        this.rowHeight = 50;
+        this.rowHeightFit = false;
+        this.gridHeight = null;
+        this.compactType = 'vertical';
+        this.transitions = [
+            { name: 'ease', value: 'transform 500ms ease, width 500ms ease, height 500ms ease' },
+            { name: 'ease-out', value: 'transform 500ms ease-out, width 500ms ease-out, height 500ms ease-out' },
+            { name: 'linear', value: 'transform 500ms linear, width 500ms linear, height 500ms linear' },
+            {
+                name: 'overflowing',
+                value: 'transform 500ms cubic-bezier(.28,.49,.79,1.35), width 500ms cubic-bezier(.28,.49,.79,1.35), height 500ms cubic-bezier(.28,.49,.79,1.35)'
+            },
+            { name: 'fast', value: 'transform 200ms ease, width 200ms linear, height 200ms linear' },
+            { name: 'slow-motion', value: 'transform 1000ms linear, width 1000ms linear, height 1000ms linear' },
+            { name: 'transform-only', value: 'transform 500ms ease' }
+        ];
+        this.currentTransition = this.transitions[0].value;
+        this.placeholders = ['None', 'Default', 'Custom 1', 'Custom 2', 'Custom 3'];
+        this.currentPlaceholder = 'Default';
+        this.dragStartThreshold = 0;
+        this.gap = 10;
+        this.autoScroll = true;
+        this.disableDrag = false;
+        this.disableResize = false;
+        this.disableRemove = false;
+        this.autoResize = true;
+        this.preventCollision = false;
+        this.isDragging = false;
+        this.isResizing = false;
+        this.showBackground = false;
+        this.gridBackgroundVisibilityOptions = ['never', 'always', 'whenDragging'];
+        this.gridBackgroundConfig = {
+            show: 'always',
+            borderColor: 'rgba(255, 128, 0, 0.25)',
+            gapColor: 'transparent',
+            borderWidth: 1,
+            rowColor: 'rgba(128, 128, 128, 0.10)',
+            columnColor: 'rgba(128, 128, 128, 0.10)'
+        };
+    }
+    ngOnInit() {
+        this.resizeSubscription = merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange'))
+            .pipe(debounceTime(50), filter(() => this.autoResize))
+            .subscribe(() => {
+            this.grid.resize();
+        });
+    }
+    ngOnDestroy() {
+        this.resizeSubscription.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        const { layout } = changes;
+        if (layout && !layout.firstChange) {
+            this.grid.resize();
+        }
+    }
+    onDragStarted(event) {
+        this.isDragging = true;
+    }
+    onResizeStarted(event) {
+        this.isResizing = true;
+    }
+    onDragEnded(event) {
+        this.isDragging = false;
+    }
+    onResizeEnded(event) {
+        this.isResizing = false;
+    }
+    onLayoutUpdated(layout) {
+        console.log('on layout updated', layout);
+        this.layout = layout;
+    }
+    onAutoScrollChange(checked) {
+        this.autoScroll = checked;
+    }
+    onDisableDragChange(checked) {
+        this.disableDrag = checked;
+    }
+    onDisableResizeChange(checked) {
+        this.disableResize = checked;
+    }
+    onShowBackgroundChange(checked) {
+        this.showBackground = checked;
+    }
+    onDisableRemoveChange(checked) {
+        this.disableRemove = checked;
+    }
+    onAutoResizeChange(checked) {
+        this.autoResize = checked;
+    }
+    onPreventCollisionChange(checked) {
+        this.preventCollision = checked;
+    }
+    onColsChange(event) {
+        this.cols = coerceNumberProperty(event.target.value);
+    }
+    onRowHeightChange(event) {
+        this.rowHeight = coerceNumberProperty(event.target.value);
+    }
+    onGridHeightChange(event) {
+        this.gridHeight = coerceNumberProperty(event.target.value);
+    }
+    onDragStartThresholdChange(event) {
+        this.dragStartThreshold = coerceNumberProperty(event.target.value);
+    }
+    onGapChange(event) {
+        this.gap = coerceNumberProperty(event.target.value);
+    }
+    generateLayout() {
+        const layout = [];
+        for (let i = 0; i < this.cols; i++) {
+            const y = Math.ceil(Math.random() * 4) + 1;
+            layout.push({
+                x: Math.round(Math.random() * Math.floor(this.cols / 2 - 1)) * 2,
+                y: Math.floor(i / 6) * y,
+                w: 2,
+                h: y,
+                id: i.toString()
+                // static: Math.random() < 0.05
+            });
+        }
+        this.layout = ktdGridCompact(layout, this.compactType, this.cols);
+        console.log('generateLayout', this.layout);
+    }
+    /** Adds a grid item to the layout */
+    addItemToLayout() {
+        const maxId = this.layout.reduce((acc, cur) => Math.max(acc, parseInt(cur.id, 10)), -1);
+        const nextId = maxId + 1;
+        const newLayoutItem = {
+            id: nextId.toString(),
+            x: -1,
+            y: -1,
+            w: 2,
+            h: 2
+        };
+        // Important: Don't mutate the array, create new instance. This way notifies the Grid component that the layout has changed.
+        this.layout = [newLayoutItem, ...this.layout];
+        this.layout = ktdGridCompact(this.layout, this.compactType, this.cols);
+    }
+    /**
+     * Fired when a mousedown happens on the remove grid item button.
+     * Stops the event from propagating an causing the drag to start.
+     * We don't want to drag when mousedown is fired on remove icon button.
+     */
+    stopEventPropagation(event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    /** Removes the item from the layout */
+    removeItem(id) {
+        // Important: Don't mutate the array. Let Angular know that the layout has changed creating a new reference.
+        this.layout = ktdArrayRemoveItem(this.layout, (item) => item.id === id);
+    }
+    updateGridBgBorderWidth(borderWidth) {
+        this.gridBackgroundConfig = {
+            ...this.gridBackgroundConfig,
+            borderWidth: Number(borderWidth)
+        };
+    }
+    updateGridBgColor(color, property) {
+        this.gridBackgroundConfig = {
+            ...this.gridBackgroundConfig,
+            [property]: color
+        };
+    }
+    getCurrentBackgroundVisibility() {
+        return this.gridBackgroundConfig?.show ?? 'never';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayoutContainerComponent, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: LayoutContainerComponent, selector: "buw-layout-container", inputs: { layout: "layout", moDataList: "moDataList" }, providers: [], viewQueries: [{ propertyName: "grid", first: true, predicate: KtdGridComponent, descendants: true, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div style=\"position: relative\" dir=\"ltr\" fillEmptySpace [setMinHeight]=\"true\">\r\n    <buw-grid\r\n        [cols]=\"cols\"\r\n        [backgroundConfig]=\"gridBackgroundConfig\"\r\n        [height]=\"rowHeightFit && gridHeight ? gridHeight : null\"\r\n        [rowHeight]=\"rowHeightFit ? 'fit' : rowHeight\"\r\n        [layout]=\"layout\"\r\n        [compactType]=\"compactType\"\r\n        [preventCollision]=\"preventCollision\"\r\n        [scrollableParent]=\"autoScroll ? document : null\"\r\n        [gap]=\"gap\"\r\n        [scrollSpeed]=\"4\"\r\n        (dragStarted)=\"onDragStarted($event)\"\r\n        (resizeStarted)=\"onResizeStarted($event)\"\r\n        (dragEnded)=\"onDragEnded($event)\"\r\n        (resizeEnded)=\"onResizeEnded($event)\"\r\n        (layoutUpdated)=\"onLayoutUpdated($event)\"\r\n    >\r\n        <buw-grid-item\r\n            *ngFor=\"let item of layout; trackBy: trackById; let i = index\"\r\n            [id]=\"item.id\"\r\n            [transition]=\"currentTransition\"\r\n            [dragStartThreshold]=\"dragStartThreshold\"\r\n            [draggable]=\"!disableDrag\"\r\n            [resizable]=\"!disableResize\"\r\n        >\r\n            <div class=\"grid-item-content\">\r\n                @if(moDataList?.length && moDataList[i]?.EjrayOlgo ){\r\n                <bnrc-dynamic-item-component [component]=\"moDataList[i].EjrayOlgo\"> </bnrc-dynamic-item-component>\r\n                }\r\n  \r\n            </div>\r\n            <div\r\n                class=\"grid-item-remove-handle\"\r\n                *ngIf=\"!disableRemove\"\r\n                (mousedown)=\"stopEventPropagation($event)\"\r\n                (click)=\"removeItem(item.id)\"\r\n            ></div>\r\n            <ng-template *ngIf=\"currentPlaceholder !== 'Default'\" buwGridItemPlaceholder>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 1'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-1\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 2'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-2\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 3'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-3\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n            </ng-template>\r\n        </buw-grid-item>\r\n    </buw-grid>\r\n</div>\r\n", styles: [":host{display:block}:host ::ng-deep .grid-item-content{box-sizing:border-box;background:#ccc;border:1px solid;width:100%;height:100%;-webkit-user-select:none;user-select:none;display:flex;align-items:center;justify-content:center}:host ::ng-deep .grid-item-remove-handle{position:absolute;cursor:pointer;display:flex;justify-content:center;width:20px;height:20px;top:0;right:0}:host ::ng-deep .grid-item-remove-handle:after{content:\"x\";color:#121212;font-size:16px;font-weight:300;font-family:Arial,sans-serif}\n"], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.DynamicItemComponent, selector: "bnrc-dynamic-item-component", inputs: ["mo", "allColumns", "moDataList", "columns", "column", "index", "last", "hideOpenIcon", "deviceName", "deviceSize", "rtl", "editMode", "setting", "parameters", "contextMenuItems", "canView", "showRowNumber", "rowNumber", "formSetting", "conditionalFormats", "disableOverflowContextMenu", "navigationArrow", "isCheckList", "fields", "isChecked", "layout94$", "inlineEditMode", "isNewInlineMo", "allowInlineEdit", "typeDefId", "rowIndicator", "rowIndicatorColor", "UlvMainCtrlr"] }, { kind: "directive", type: i2.FillEmptySpaceDirective, selector: "[fillEmptySpace]", inputs: ["containerDom", "decrement", "disable", "height", "dontUseTopBound", "setMinHeight"], exportAs: ["fillEmptySpace"] }, { kind: "component", type: i3.KtdGridComponent, selector: "buw-grid", inputs: ["scrollableParent", "compactOnPropsChange", "preventCollision", "scrollSpeed", "compactType", "rowHeight", "cols", "layout", "gap", "height", "backgroundConfig"], outputs: ["layoutUpdated", "dragStarted", "resizeStarted", "dragEnded", "resizeEnded", "gridItemResize"] }, { kind: "component", type: i4.KtdGridItemComponent, selector: "buw-grid-item", inputs: ["minW", "minH", "maxW", "maxH", "transition", "id", "dragStartThreshold", "draggable", "resizable"] }, { kind: "directive", type: i5.KtdGridItemPlaceholder, selector: "ng-template[buwGridItemPlaceholder]", inputs: ["data"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LayoutContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'buw-layout-container', providers: [], changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "<div style=\"position: relative\" dir=\"ltr\" fillEmptySpace [setMinHeight]=\"true\">\r\n    <buw-grid\r\n        [cols]=\"cols\"\r\n        [backgroundConfig]=\"gridBackgroundConfig\"\r\n        [height]=\"rowHeightFit && gridHeight ? gridHeight : null\"\r\n        [rowHeight]=\"rowHeightFit ? 'fit' : rowHeight\"\r\n        [layout]=\"layout\"\r\n        [compactType]=\"compactType\"\r\n        [preventCollision]=\"preventCollision\"\r\n        [scrollableParent]=\"autoScroll ? document : null\"\r\n        [gap]=\"gap\"\r\n        [scrollSpeed]=\"4\"\r\n        (dragStarted)=\"onDragStarted($event)\"\r\n        (resizeStarted)=\"onResizeStarted($event)\"\r\n        (dragEnded)=\"onDragEnded($event)\"\r\n        (resizeEnded)=\"onResizeEnded($event)\"\r\n        (layoutUpdated)=\"onLayoutUpdated($event)\"\r\n    >\r\n        <buw-grid-item\r\n            *ngFor=\"let item of layout; trackBy: trackById; let i = index\"\r\n            [id]=\"item.id\"\r\n            [transition]=\"currentTransition\"\r\n            [dragStartThreshold]=\"dragStartThreshold\"\r\n            [draggable]=\"!disableDrag\"\r\n            [resizable]=\"!disableResize\"\r\n        >\r\n            <div class=\"grid-item-content\">\r\n                @if(moDataList?.length && moDataList[i]?.EjrayOlgo ){\r\n                <bnrc-dynamic-item-component [component]=\"moDataList[i].EjrayOlgo\"> </bnrc-dynamic-item-component>\r\n                }\r\n  \r\n            </div>\r\n            <div\r\n                class=\"grid-item-remove-handle\"\r\n                *ngIf=\"!disableRemove\"\r\n                (mousedown)=\"stopEventPropagation($event)\"\r\n                (click)=\"removeItem(item.id)\"\r\n            ></div>\r\n            <ng-template *ngIf=\"currentPlaceholder !== 'Default'\" buwGridItemPlaceholder>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 1'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-1\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 2'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-2\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 3'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-3\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n            </ng-template>\r\n        </buw-grid-item>\r\n    </buw-grid>\r\n</div>\r\n", styles: [":host{display:block}:host ::ng-deep .grid-item-content{box-sizing:border-box;background:#ccc;border:1px solid;width:100%;height:100%;-webkit-user-select:none;user-select:none;display:flex;align-items:center;justify-content:center}:host ::ng-deep .grid-item-remove-handle{position:absolute;cursor:pointer;display:flex;justify-content:center;width:20px;height:20px;top:0;right:0}:host ::ng-deep .grid-item-remove-handle:after{content:\"x\";color:#121212;font-size:16px;font-weight:300;font-family:Arial,sans-serif}\n"] }]
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }], propDecorators: { grid: [{
+                type: ViewChild,
+                args: [KtdGridComponent, { static: true }]
+            }], layout: [{
+                type: Input
+            }], moDataList: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layout-container.component.js","sourceRoot":"","sources":["../../../../../projects/barsa-user-workspace/src/lib/layout-container/layout-container.component.ts","../../../../../projects/barsa-user-workspace/src/lib/layout-container/layout-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceNumberProperty } from '@angular/cdk/coercion';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport {\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    ElementRef,\r\n    Inject,\r\n    NgZone,\r\n    OnDestroy,\r\n    OnInit,\r\n    ViewChild,\r\n    Input,\r\n    SimpleChanges\r\n} from '@angular/core';\r\n\r\nimport { BaseComponent, MetaobjectDataModel } from 'barsa-novin-ray-core';\r\nimport { debounceTime, filter, fromEvent, merge, Subscription } from 'rxjs';\r\nimport { KtdDragEnd, KtdDragStart, KtdGridComponent, KtdResizeEnd, KtdResizeStart } from '../grid/grid.component';\r\nimport { ktdGridCompact, ktdTrackById } from '../utils/grid.utils';\r\nimport { KtdGridBackgroundCfg, KtdGridLayout, KtdGridLayoutItem } from '../grid.definitions';\r\nimport { ktdArrayRemoveItem } from '../utils';\r\n\r\n@Component({\r\n    selector: 'buw-layout-container',\r\n    templateUrl: './layout-container.component.html',\r\n    styleUrls: ['./layout-container.component.scss'],\r\n    providers: [],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    standalone: false\r\n})\r\nexport class LayoutContainerComponent extends BaseComponent implements OnInit, OnDestroy {\r\n    @ViewChild(KtdGridComponent, { static: true }) grid: KtdGridComponent;\r\n    // @Input() layout: KtdGridLayout = [{ id: '0', x: 5, y: 0, w: 2, h: 3 }];\r\n    @Input() layout: KtdGridLayout = [];\r\n    @Input() moDataList: MetaobjectDataModel[] = [];\r\n\r\n    trackById = ktdTrackById;\r\n\r\n    cols = 12;\r\n    rowHeight = 50;\r\n    rowHeightFit = false;\r\n    gridHeight: null | number = null;\r\n    compactType: 'vertical' | 'horizontal' | null = 'vertical';\r\n    transitions: { name: string; value: string }[] = [\r\n        { name: 'ease', value: 'transform 500ms ease, width 500ms ease, height 500ms ease' },\r\n        { name: 'ease-out', value: 'transform 500ms ease-out, width 500ms ease-out, height 500ms ease-out' },\r\n        { name: 'linear', value: 'transform 500ms linear, width 500ms linear, height 500ms linear' },\r\n        {\r\n            name: 'overflowing',\r\n            value: 'transform 500ms cubic-bezier(.28,.49,.79,1.35), width 500ms cubic-bezier(.28,.49,.79,1.35), height 500ms cubic-bezier(.28,.49,.79,1.35)'\r\n        },\r\n        { name: 'fast', value: 'transform 200ms ease, width 200ms linear, height 200ms linear' },\r\n        { name: 'slow-motion', value: 'transform 1000ms linear, width 1000ms linear, height 1000ms linear' },\r\n        { name: 'transform-only', value: 'transform 500ms ease' }\r\n    ];\r\n    currentTransition: string = this.transitions[0].value;\r\n\r\n    placeholders: string[] = ['None', 'Default', 'Custom 1', 'Custom 2', 'Custom 3'];\r\n\r\n    currentPlaceholder = 'Default';\r\n\r\n    dragStartThreshold = 0;\r\n    gap = 10;\r\n    autoScroll = true;\r\n    disableDrag = false;\r\n    disableResize = false;\r\n    disableRemove = false;\r\n    autoResize = true;\r\n    preventCollision = false;\r\n    isDragging = false;\r\n    isResizing = false;\r\n    showBackground = false;\r\n    resizeSubscription: Subscription;\r\n\r\n    gridBackgroundVisibilityOptions = ['never', 'always', 'whenDragging'];\r\n    gridBackgroundConfig: Required<KtdGridBackgroundCfg> = {\r\n        show: 'always',\r\n        borderColor: 'rgba(255, 128, 0, 0.25)',\r\n        gapColor: 'transparent',\r\n        borderWidth: 1,\r\n        rowColor: 'rgba(128, 128, 128, 0.10)',\r\n        columnColor: 'rgba(128, 128, 128, 0.10)'\r\n    };\r\n\r\n    constructor(private ngZone: NgZone, public elementRef: ElementRef, @Inject(DOCUMENT) public document: Document) {\r\n        // this.ngZone.onUnstable.subscribe(() => console.log('UnStable'));\r\n        super();\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this.resizeSubscription = merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange'))\r\n            .pipe(\r\n                debounceTime(50),\r\n                filter(() => this.autoResize)\r\n            )\r\n            .subscribe(() => {\r\n                this.grid.resize();\r\n            });\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.resizeSubscription.unsubscribe();\r\n    }\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        super.ngOnChanges(changes);\r\n        const { layout } = changes;\r\n        if (layout && !layout.firstChange) {\r\n            this.grid.resize();\r\n        }\r\n    }\r\n\r\n    onDragStarted(event: KtdDragStart): void {\r\n        this.isDragging = true;\r\n    }\r\n\r\n    onResizeStarted(event: KtdResizeStart): void {\r\n        this.isResizing = true;\r\n    }\r\n\r\n    onDragEnded(event: KtdDragEnd): void {\r\n        this.isDragging = false;\r\n    }\r\n\r\n    onResizeEnded(event: KtdResizeEnd): void {\r\n        this.isResizing = false;\r\n    }\r\n\r\n    onLayoutUpdated(layout: KtdGridLayout): void {\r\n        console.log('on layout updated', layout);\r\n        this.layout = layout;\r\n    }\r\n\r\n    onAutoScrollChange(checked: boolean): void {\r\n        this.autoScroll = checked;\r\n    }\r\n\r\n    onDisableDragChange(checked: boolean): void {\r\n        this.disableDrag = checked;\r\n    }\r\n\r\n    onDisableResizeChange(checked: boolean): void {\r\n        this.disableResize = checked;\r\n    }\r\n\r\n    onShowBackgroundChange(checked: boolean): void {\r\n        this.showBackground = checked;\r\n    }\r\n\r\n    onDisableRemoveChange(checked: boolean): void {\r\n        this.disableRemove = checked;\r\n    }\r\n\r\n    onAutoResizeChange(checked: boolean): void {\r\n        this.autoResize = checked;\r\n    }\r\n\r\n    onPreventCollisionChange(checked: boolean): void {\r\n        this.preventCollision = checked;\r\n    }\r\n\r\n    onColsChange(event: Event): void {\r\n        this.cols = coerceNumberProperty((event.target as HTMLInputElement).value);\r\n    }\r\n\r\n    onRowHeightChange(event: Event): void {\r\n        this.rowHeight = coerceNumberProperty((event.target as HTMLInputElement).value);\r\n    }\r\n\r\n    onGridHeightChange(event: Event): void {\r\n        this.gridHeight = coerceNumberProperty((event.target as HTMLInputElement).value);\r\n    }\r\n\r\n    onDragStartThresholdChange(event: Event): void {\r\n        this.dragStartThreshold = coerceNumberProperty((event.target as HTMLInputElement).value);\r\n    }\r\n\r\n    onGapChange(event: Event): void {\r\n        this.gap = coerceNumberProperty((event.target as HTMLInputElement).value);\r\n    }\r\n\r\n    generateLayout(): void {\r\n        const layout: KtdGridLayout = [];\r\n        for (let i = 0; i < this.cols; i++) {\r\n            const y = Math.ceil(Math.random() * 4) + 1;\r\n            layout.push({\r\n                x: Math.round(Math.random() * Math.floor(this.cols / 2 - 1)) * 2,\r\n                y: Math.floor(i / 6) * y,\r\n                w: 2,\r\n                h: y,\r\n                id: i.toString()\r\n                // static: Math.random() < 0.05\r\n            });\r\n        }\r\n        this.layout = ktdGridCompact(layout, this.compactType, this.cols);\r\n        console.log('generateLayout', this.layout);\r\n    }\r\n\r\n    /** Adds a grid item to the layout */\r\n    addItemToLayout(): void {\r\n        const maxId = this.layout.reduce((acc, cur) => Math.max(acc, parseInt(cur.id, 10)), -1);\r\n        const nextId = maxId + 1;\r\n\r\n        const newLayoutItem: KtdGridLayoutItem = {\r\n            id: nextId.toString(),\r\n            x: -1,\r\n            y: -1,\r\n            w: 2,\r\n            h: 2\r\n        };\r\n\r\n        // Important: Don't mutate the array, create new instance. This way notifies the Grid component that the layout has changed.\r\n        this.layout = [newLayoutItem, ...this.layout];\r\n\r\n        this.layout = ktdGridCompact(this.layout, this.compactType, this.cols);\r\n    }\r\n\r\n    /**\r\n     * Fired when a mousedown happens on the remove grid item button.\r\n     * Stops the event from propagating an causing the drag to start.\r\n     * We don't want to drag when mousedown is fired on remove icon button.\r\n     */\r\n    stopEventPropagation(event: Event): void {\r\n        event.preventDefault();\r\n        event.stopPropagation();\r\n    }\r\n\r\n    /** Removes the item from the layout */\r\n    removeItem(id: string): void {\r\n        // Important: Don't mutate the array. Let Angular know that the layout has changed creating a new reference.\r\n        this.layout = ktdArrayRemoveItem(this.layout, (item) => item.id === id);\r\n    }\r\n\r\n    updateGridBgBorderWidth(borderWidth: string): void {\r\n        this.gridBackgroundConfig = {\r\n            ...this.gridBackgroundConfig,\r\n            borderWidth: Number(borderWidth)\r\n        };\r\n    }\r\n\r\n    updateGridBgColor(color: string, property: string): void {\r\n        this.gridBackgroundConfig = {\r\n            ...this.gridBackgroundConfig,\r\n            [property]: color\r\n        };\r\n    }\r\n\r\n    getCurrentBackgroundVisibility(): string {\r\n        return this.gridBackgroundConfig?.show ?? 'never';\r\n    }\r\n}\r\n","<div style=\"position: relative\" dir=\"ltr\" fillEmptySpace [setMinHeight]=\"true\">\r\n    <buw-grid\r\n        [cols]=\"cols\"\r\n        [backgroundConfig]=\"gridBackgroundConfig\"\r\n        [height]=\"rowHeightFit && gridHeight ? gridHeight : null\"\r\n        [rowHeight]=\"rowHeightFit ? 'fit' : rowHeight\"\r\n        [layout]=\"layout\"\r\n        [compactType]=\"compactType\"\r\n        [preventCollision]=\"preventCollision\"\r\n        [scrollableParent]=\"autoScroll ? document : null\"\r\n        [gap]=\"gap\"\r\n        [scrollSpeed]=\"4\"\r\n        (dragStarted)=\"onDragStarted($event)\"\r\n        (resizeStarted)=\"onResizeStarted($event)\"\r\n        (dragEnded)=\"onDragEnded($event)\"\r\n        (resizeEnded)=\"onResizeEnded($event)\"\r\n        (layoutUpdated)=\"onLayoutUpdated($event)\"\r\n    >\r\n        <buw-grid-item\r\n            *ngFor=\"let item of layout; trackBy: trackById; let i = index\"\r\n            [id]=\"item.id\"\r\n            [transition]=\"currentTransition\"\r\n            [dragStartThreshold]=\"dragStartThreshold\"\r\n            [draggable]=\"!disableDrag\"\r\n            [resizable]=\"!disableResize\"\r\n        >\r\n            <div class=\"grid-item-content\">\r\n                @if(moDataList?.length && moDataList[i]?.EjrayOlgo ){\r\n                <bnrc-dynamic-item-component [component]=\"moDataList[i].EjrayOlgo\"> </bnrc-dynamic-item-component>\r\n                }\r\n  \r\n            </div>\r\n            <div\r\n                class=\"grid-item-remove-handle\"\r\n                *ngIf=\"!disableRemove\"\r\n                (mousedown)=\"stopEventPropagation($event)\"\r\n                (click)=\"removeItem(item.id)\"\r\n            ></div>\r\n            <ng-template *ngIf=\"currentPlaceholder !== 'Default'\" buwGridItemPlaceholder>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 1'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-1\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 2'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-2\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n                <div\r\n                    *ngIf=\"currentPlaceholder === 'Custom 3'\"\r\n                    class=\"grid-item-content custom-placeholder custom-placeholder-3\"\r\n                >\r\n                    {{ item.id }}\r\n                </div>\r\n            </ng-template>\r\n        </buw-grid-item>\r\n    </buw-grid>\r\n</div>\r\n"]}