@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/grid-layout/components/grid/component.mjs

@@ -0,0 +1,286 @@
+import { __decorate, __metadata } from "tslib";
+import { observeResizeOn } from '@alauda/ui';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChildren, ElementRef, EventEmitter, Inject, Input, NgZone, Output, QueryList, Renderer2, ViewContainerRef, ViewEncapsulation, } from '@angular/core';
+import { cloneDeep, isEqual } from 'lodash-es';
+import { combineLatest, distinctUntilChanged, exhaustMap, map, merge, NEVER, Observable, startWith, Subject, switchMap, takeUntil, } from 'rxjs';
+import { DEFAULT_GUTTER, DEFAULT_LAYOUT_COLUMNS, DEFAULT_ROW_HEIGHT, ObservableInput, } from '../../../public-api';
+import { GridLayoutService } from '../../grid-layout.service';
+import { GridPlaceholderService } from '../../grid-placeholder.service';
+import { GridCompactType, } from '../../type';
+import { getClientRectSnapshot } from '../../utils/client-rect.utils';
+import { compactGridLayout, getDragResizeEventData, } from '../../utils/grid.utils';
+import { getMouseEnd$, getMouseMove$ } from '../../utils/mouse.utils';
+import { runOutsideZone$ } from '../../utils/operator';
+import { scrollIfNearElementClientRect$ } from '../../utils/scroll.utils';
+import { GridItemComponent } from '../grid-items/component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../grid-placeholder.service";
+import * as i2 from "../../grid-layout.service";
+const _c0 = ["*"];
+export class GridLayoutComponent {
+    get config() {
+        return {
+            cols: this.cols,
+            rowHeight: this.rowHeight,
+            layout: this.lastLayout,
+            preventCollision: this.preventCollision,
+            gutter: this.gutter,
+        };
+    }
+    get hostElement() {
+        return this.elementRef.nativeElement;
+    }
+    constructor(elementRef, viewContainerRef, renderer, ngZone, gridPlaceholderService, document, gridLayoutService) {
+        this.elementRef = elementRef;
+        this.viewContainerRef = viewContainerRef;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        this.gridPlaceholderService = gridPlaceholderService;
+        this.document = document;
+        this.gridLayoutService = gridLayoutService;
+        this.layoutUpdated = new EventEmitter();
+        this.dragStarted = new EventEmitter();
+        this.resizeStarted = new EventEmitter();
+        this.dragEnded = new EventEmitter();
+        this.resizeEnded = new EventEmitter();
+        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.
+        // use this to compensate dragging point and scroll difference
+        this.scrollableParent = null;
+        this.preventCollision = false;
+        this.scrollSpeed = 2;
+        this.compactType = GridCompactType.VERTICAL;
+        this.rowHeight = DEFAULT_ROW_HEIGHT;
+        this.cols = DEFAULT_LAYOUT_COLUMNS;
+        this.gutter = DEFAULT_GUTTER;
+        this.destroy$$ = new Subject();
+        this.markLayoutIdChange = false;
+        // we use this pattern to avoid too many property passing
+        this.gridLayoutService.registerGridComponent(this);
+    }
+    ngOnInit() {
+        observeResizeOn(this.hostElement)
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(() => {
+            this.gridLayoutService.calculateRenderData();
+            this.gridLayoutService.flushRenderData(true);
+        });
+        this.gridLayoutService.gridRenderHeight$$
+            .pipe(takeUntil(this.destroy$$), distinctUntilChanged(isEqual))
+            .subscribe(height => {
+            this.renderer.setStyle(this.hostElement, 'height', `${height}px`);
+        });
+    }
+    ngOnChanges(changes) {
+        let needsCompactLayout = false;
+        let needsRecalculateRenderData = false;
+        // Compact layout whenever some dependent prop changes.
+        if (changes.compactType || changes.cols || changes.layout || changes.id) {
+            needsCompactLayout = true;
+        }
+        if (changes.layout) {
+            this.lastLayout = changes.layout.currentValue;
+        }
+        if (changes.id) {
+            if (this.lastLayoutId && this.lastLayoutId !== changes.id.currentValue) {
+                this.markLayoutIdChange = true;
+            }
+            this.lastLayoutId = changes.id.currentValue;
+        }
+        // Check if wee need to recalculate rendering data.
+        if (needsCompactLayout ||
+            changes.rowHeight ||
+            changes.gutter ||
+            changes.layout) {
+            needsRecalculateRenderData = true;
+        }
+        const markLayoutIdChange = this.markLayoutIdChange;
+        if (needsRecalculateRenderData) {
+            // let ngOnChanges pass, we can use input props, and when props change, let grid-component destroy first
+            requestAnimationFrame(() => {
+                if (needsCompactLayout) {
+                    this.compactLayout(markLayoutIdChange);
+                }
+                this.gridLayoutService.calculateRenderData();
+                // Do not need animation when total layout config change, which is dashId changing
+                this.gridLayoutService.flushRenderData(!markLayoutIdChange);
+            });
+        }
+    }
+    ngAfterContentInit() {
+        this.initSubscriptions();
+    }
+    ngAfterContentChecked() {
+        this.gridLayoutService.calculateRenderData();
+        this.gridLayoutService.flushRenderData(!this.markLayoutIdChange);
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    refreshLayout(dashIdChange) {
+        return dashIdChange
+            ? this.lastLayout
+            : this.lastLayout?.map(layoutItem => ({
+                ...layoutItem,
+                ...this.gridLayoutService.lastLayout?.find(({ id }) => layoutItem.id === id),
+            }));
+    }
+    compactLayout(dashIdChange) {
+        this.lastLayout = compactGridLayout(this.refreshLayout(dashIdChange), this.compactType, this.cols);
+    }
+    getItemRenderData(itemId) {
+        return this.gridLayoutService.gridItemsRenderData[itemId];
+    }
+    initSubscriptions() {
+        this.gridItems.changes.pipe(takeUntil(this.destroy$$)).subscribe(() => {
+            const markLayoutIdChange = this.markLayoutIdChange;
+            // need this Raf to make this.lastLayout to be last
+            requestAnimationFrame(() => {
+                this.markLayoutIdChange = false;
+                this.compactLayout(!markLayoutIdChange);
+                this.gridLayoutService.calculateRenderData();
+                this.gridLayoutService.flushRenderData(!markLayoutIdChange);
+            });
+        });
+        this.gridItems.changes
+            .pipe(takeUntil(this.destroy$$), 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 }) => {
+            this.ngZone.run(() => (type === 'drag' ? this.dragStarted : this.resizeStarted).emit(getDragResizeEventData(gridItem, this.lastLayout)));
+            return this.handleAction$(gridItem, event, type).pipe(map(layout => ({ layout, gridItem, type })));
+        }))))
+            .subscribe(({ layout, gridItem, type }) => {
+            this.lastLayout = layout;
+            (type === 'drag' ? this.dragEnded : this.resizeEnded).emit(getDragResizeEventData(gridItem, layout));
+            this.layoutUpdated.emit(layout);
+        });
+    }
+    handleAction$(gridItem, pointerDownEvent, type) {
+        return new Observable((observer) => {
+            // Retrieve grid (parent) and gridItem (draggedElem) client rects.
+            const gridElemClientRectSnapshot = getClientRectSnapshot(this.elementRef.nativeElement);
+            const dragElemClientRectSnapshot = getClientRectSnapshot(gridItem.elementRef.nativeElement);
+            const scrollableParent = typeof this.scrollableParent === 'string'
+                ? document.querySelector(this.scrollableParent)
+                : this.scrollableParent;
+            this.renderer.addClass(gridItem.elementRef.nativeElement, 'no-transitions');
+            this.renderer.addClass(gridItem.elementRef.nativeElement, 'grid-item-dragging');
+            const placeholderClientRect = {
+                ...dragElemClientRectSnapshot,
+                left: dragElemClientRectSnapshot.left - gridElemClientRectSnapshot.left,
+                top: dragElemClientRectSnapshot.top - gridElemClientRectSnapshot.top,
+            };
+            this.gridPlaceholderService.createPlaceholderElement(placeholderClientRect, this.elementRef, this.viewContainerRef, gridItem.placeholder);
+            let newLayout;
+            (scrollableParent
+                ? getMouseMove$(this.document.documentElement).pipe(runOutsideZone$(this.ngZone), takeUntil(this.destroy$$), scrollIfNearElementClientRect$(scrollableParent, {
+                    scrollStep: this.scrollSpeed,
+                }))
+                : NEVER)
+                .pipe(takeUntil(getMouseEnd$(this.document.documentElement)))
+                .subscribe();
+            merge(combineLatest([
+                getMouseMove$(this.document.documentElement),
+                this.gridLayoutService.scrollDifference$,
+            ]))
+                .pipe(runOutsideZone$(this.ngZone), takeUntil(getMouseEnd$(this.document.documentElement)), takeUntil(this.destroy$$))
+                .subscribe(([pointerDragEvent, scrollDifference]) => {
+                pointerDragEvent.preventDefault();
+                const gridItemId = gridItem.id;
+                const { gridData, layout } = this.gridLayoutService.layoutWhenAction(gridItem, type, {
+                    pointerDownEvent,
+                    pointerDragEvent,
+                }, scrollDifference, dragElemClientRectSnapshot, gridElemClientRectSnapshot);
+                this.gridLayoutService.flushRenderData();
+                newLayout = cloneDeep(layout);
+                const newItemGridData = { ...gridData[gridItemId] };
+                // put the grid normalize position to the placeholder element
+                this.gridPlaceholderService.updatePlaceHolder(newItemGridData);
+                type === 'resize' &&
+                    this.gridItemResize.emit({
+                        width: newItemGridData.width,
+                        height: newItemGridData.height,
+                        gridItemRef: getDragResizeEventData(gridItem, newLayout)
+                            .gridItemRef,
+                    });
+            }, error => observer.error(error), () => {
+                this.ngZone.run(() => {
+                    this.renderer.removeClass(gridItem.elementRef.nativeElement, 'no-transitions');
+                    this.renderer.removeClass(gridItem.elementRef.nativeElement, 'grid-item-dragging');
+                    // when action is done, use another relayout to make sure everything is fine
+                    this.compactLayout(false);
+                    this.gridLayoutService.calculateRenderData();
+                    this.gridLayoutService.flushRenderData();
+                    this.gridPlaceholderService.destroyPlaceholder();
+                    if (newLayout) {
+                        observer.next(cloneDeep(newLayout));
+                    }
+                    observer.complete();
+                });
+            });
+        });
+    }
+    static { this.ɵfac = function GridLayoutComponent_Factory(t) { return new (t || GridLayoutComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i0.ViewContainerRef), i0.ɵɵdirectiveInject(i0.Renderer2), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i1.GridPlaceholderService), i0.ɵɵdirectiveInject(DOCUMENT), i0.ɵɵdirectiveInject(i2.GridLayoutService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: GridLayoutComponent, selectors: [["acl-grid-layout"]], contentQueries: function GridLayoutComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, GridItemComponent, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.gridItems = _t);
+        } }, inputs: { scrollableParent: "scrollableParent", id: "id", preventCollision: "preventCollision", scrollSpeed: "scrollSpeed", compactType: "compactType", rowHeight: "rowHeight", cols: "cols", layout: "layout", gutter: "gutter" }, outputs: { layoutUpdated: "layoutUpdated", dragStarted: "dragStarted", resizeStarted: "resizeStarted", dragEnded: "dragEnded", resizeEnded: "resizeEnded", gridItemResize: "gridItemResize" }, features: [i0.ɵɵProvidersFeature([GridPlaceholderService, GridLayoutService]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function GridLayoutComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, styles: ["acl-grid-layout{display:block;position:relative;width:100%}acl-grid-layout acl-grid-item.grid-item-dragging{z-index:500}acl-grid-layout acl-grid-item.no-transitions{transition:none!important}acl-grid-layout .grid-item-placeholder-default{transition:all .15s ease;position:absolute;background-color:rgb(var(--aui-color-p-6));z-index:0;border-radius:var(--aui-border-radius-l);border-top-left-radius:.25rem;border-bottom-left-radius:.25rem;--tw-shadow: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);--tw-shadow-colored: 0 4px 6px -1px var(--tw-shadow-color), 0 2px 4px -2px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow);border:1px dashed rgb(var(--aui-color-primary))}\n"], encapsulation: 2, changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], GridLayoutComponent.prototype, "scrollableParent$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GridLayoutComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-grid-layout', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [GridPlaceholderService, GridLayoutService], template: "<ng-content></ng-content>\n", styles: ["acl-grid-layout{display:block;position:relative;width:100%}acl-grid-layout acl-grid-item.grid-item-dragging{z-index:500}acl-grid-layout acl-grid-item.no-transitions{transition:none!important}acl-grid-layout .grid-item-placeholder-default{transition:all .15s ease;position:absolute;background-color:rgb(var(--aui-color-p-6));z-index:0;border-radius:var(--aui-border-radius-l);border-top-left-radius:.25rem;border-bottom-left-radius:.25rem;--tw-shadow: 0 4px 6px -1px rgb(0 0 0 / .1), 0 2px 4px -2px rgb(0 0 0 / .1);--tw-shadow-colored: 0 4px 6px -1px var(--tw-shadow-color), 0 2px 4px -2px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow);border:1px dashed rgb(var(--aui-color-primary))}\n"] }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i0.ViewContainerRef }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i1.GridPlaceholderService }, { type: Document, decorators: [{
+                type: Inject,
+                args: [DOCUMENT]
+            }] }, { type: i2.GridLayoutService }]; }, { gridItems: [{
+            type: ContentChildren,
+            args: [GridItemComponent, { descendants: true }]
+        }], layoutUpdated: [{
+            type: Output
+        }], dragStarted: [{
+            type: Output
+        }], resizeStarted: [{
+            type: Output
+        }], dragEnded: [{
+            type: Output
+        }], resizeEnded: [{
+            type: Output
+        }], gridItemResize: [{
+            type: Output
+        }], scrollableParent: [{
+            type: Input
+        }], scrollableParent$: [], id: [{
+            type: Input
+        }], preventCollision: [{
+            type: Input
+        }], scrollSpeed: [{
+            type: Input
+        }], compactType: [{
+            type: Input
+        }], rowHeight: [{
+            type: Input
+        }], cols: [{
+            type: Input
+        }], layout: [{
+            type: Input
+        }], gutter: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../libs/common/src/grid-layout/components/grid/component.ts","../../../../../../../libs/common/src/grid-layout/components/grid/template.html"],"names":[],"mappings":"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","sourcesContent":["import { observeResizeOn } from '@alauda/ui';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  AfterContentChecked,\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  Renderer2,\n  SimpleChanges,\n  ViewContainerRef,\n  ViewEncapsulation,\n} from '@angular/core';\nimport { cloneDeep, isEqual } from 'lodash-es';\nimport {\n  combineLatest,\n  distinctUntilChanged,\n  exhaustMap,\n  map,\n  merge,\n  NEVER,\n  Observable,\n  Observer,\n  startWith,\n  Subject,\n  switchMap,\n  takeUntil,\n} from 'rxjs';\n\nimport {\n  DEFAULT_GUTTER,\n  DEFAULT_LAYOUT_COLUMNS,\n  DEFAULT_ROW_HEIGHT,\n  ObservableInput,\n} from '../../../public-api';\nimport { GridLayoutService } from '../../grid-layout.service';\nimport { GridPlaceholderService } from '../../grid-placeholder.service';\nimport {\n  GridCompactType,\n  DragEndEvent,\n  DragStartEvent,\n  GridLayout,\n  GridLayoutItem,\n  ResizeStartEvent,\n  GridCfg,\n  GridItemRenderData,\n  GridItemClientRect,\n  DragActionType,\n  ResizeEndEvent,\n  ItemResizeEvent,\n} from '../../type';\nimport { getClientRectSnapshot } from '../../utils/client-rect.utils';\nimport {\n  compactGridLayout,\n  getDragResizeEventData,\n} from '../../utils/grid.utils';\nimport { getMouseEnd$, getMouseMove$ } from '../../utils/mouse.utils';\nimport { runOutsideZone$ } from '../../utils/operator';\nimport { scrollIfNearElementClientRect$ } from '../../utils/scroll.utils';\nimport { GridItemComponent } from '../grid-items/component';\n\n@Component({\n  selector: 'acl-grid-layout',\n  templateUrl: './template.html',\n  encapsulation: ViewEncapsulation.None,\n  styleUrls: ['./style.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [GridPlaceholderService, GridLayoutService],\n})\nexport class GridLayoutComponent\n  implements\n    OnInit,\n    OnChanges,\n    AfterContentChecked,\n    AfterContentInit,\n    OnDestroy\n{\n  /** Query list of grid items that are being rendered. */\n  @ContentChildren(GridItemComponent, { descendants: true })\n  gridItems: QueryList<GridItemComponent>;\n\n  @Output() layoutUpdated: EventEmitter<GridLayout> =\n    new EventEmitter<GridLayout>();\n\n  @Output() dragStarted: EventEmitter<DragStartEvent> =\n    new EventEmitter<DragStartEvent>();\n\n  @Output() resizeStarted: EventEmitter<ResizeStartEvent> =\n    new EventEmitter<ResizeStartEvent>();\n\n  @Output() dragEnded: EventEmitter<DragEndEvent> =\n    new EventEmitter<DragEndEvent>();\n\n  @Output() resizeEnded: EventEmitter<ResizeEndEvent> =\n    new EventEmitter<ResizeEndEvent>();\n\n  @Output() gridItemResize: EventEmitter<ItemResizeEvent> =\n    new EventEmitter<ItemResizeEvent>();\n\n  // Parent element that contains the scroll. If an string is provided it would search that element by id on the dom.\n  // use this to compensate dragging point and scroll difference\n  @Input() scrollableParent: HTMLElement | Document | string | null = null;\n  @ObservableInput() scrollableParent$: Observable<\n    HTMLElement | Document | string | null\n  >;\n\n  @Input()\n  id: string;\n\n  @Input()\n  preventCollision = false;\n\n  @Input()\n  scrollSpeed = 2;\n\n  @Input()\n  compactType = GridCompactType.VERTICAL;\n\n  @Input()\n  rowHeight: number = DEFAULT_ROW_HEIGHT;\n\n  @Input()\n  cols: number = DEFAULT_LAYOUT_COLUMNS;\n\n  @Input()\n  layout: GridLayout;\n\n  @Input()\n  gutter: number = DEFAULT_GUTTER;\n\n  private lastLayout: GridLayout;\n\n  destroy$$ = new Subject<void>();\n\n  get config(): GridCfg {\n    return {\n      cols: this.cols,\n      rowHeight: this.rowHeight,\n      layout: this.lastLayout,\n      preventCollision: this.preventCollision,\n      gutter: this.gutter,\n    };\n  }\n\n  get hostElement() {\n    return this.elementRef.nativeElement as HTMLElement;\n  }\n\n  constructor(\n    public elementRef: ElementRef,\n    public viewContainerRef: ViewContainerRef,\n    private readonly renderer: Renderer2,\n    private readonly ngZone: NgZone,\n    private readonly gridPlaceholderService: GridPlaceholderService,\n    @Inject(DOCUMENT) private readonly document: Document,\n    private readonly gridLayoutService: GridLayoutService,\n  ) {\n    // we use this pattern to avoid too many property passing\n    this.gridLayoutService.registerGridComponent(this);\n  }\n\n  ngOnInit() {\n    observeResizeOn(this.hostElement)\n      .pipe(takeUntil(this.destroy$$))\n      .subscribe(() => {\n        this.gridLayoutService.calculateRenderData();\n        this.gridLayoutService.flushRenderData(true);\n      });\n    this.gridLayoutService.gridRenderHeight$$\n      .pipe(takeUntil(this.destroy$$), distinctUntilChanged(isEqual))\n      .subscribe(height => {\n        this.renderer.setStyle(this.hostElement, 'height', `${height}px`);\n      });\n  }\n\n  private lastLayoutId: string;\n  private markLayoutIdChange = false;\n\n  ngOnChanges(changes: SimpleChanges) {\n    let needsCompactLayout = false;\n    let needsRecalculateRenderData = false;\n    // Compact layout whenever some dependent prop changes.\n    if (changes.compactType || changes.cols || changes.layout || changes.id) {\n      needsCompactLayout = true;\n    }\n    if (changes.layout) {\n      this.lastLayout = changes.layout.currentValue;\n    }\n    if (changes.id) {\n      if (this.lastLayoutId && this.lastLayoutId !== changes.id.currentValue) {\n        this.markLayoutIdChange = true;\n      }\n      this.lastLayoutId = changes.id.currentValue;\n    }\n\n    // Check if wee need to recalculate rendering data.\n    if (\n      needsCompactLayout ||\n      changes.rowHeight ||\n      changes.gutter ||\n      changes.layout\n    ) {\n      needsRecalculateRenderData = true;\n    }\n    const markLayoutIdChange = this.markLayoutIdChange;\n    if (needsRecalculateRenderData) {\n      // let ngOnChanges pass, we can use input props, and when props change, let grid-component destroy first\n      requestAnimationFrame(() => {\n        if (needsCompactLayout) {\n          this.compactLayout(markLayoutIdChange);\n        }\n        this.gridLayoutService.calculateRenderData();\n        // Do not need animation when total layout config change, which is dashId changing\n        this.gridLayoutService.flushRenderData(!markLayoutIdChange);\n      });\n    }\n  }\n\n  ngAfterContentInit() {\n    this.initSubscriptions();\n  }\n\n  ngAfterContentChecked() {\n    this.gridLayoutService.calculateRenderData();\n    this.gridLayoutService.flushRenderData(!this.markLayoutIdChange);\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  refreshLayout(dashIdChange: boolean) {\n    return dashIdChange\n      ? this.lastLayout\n      : this.lastLayout?.map(layoutItem => ({\n          ...layoutItem,\n          ...this.gridLayoutService.lastLayout?.find(\n            ({ id }) => layoutItem.id === id,\n          ),\n        }));\n  }\n\n  compactLayout(dashIdChange: boolean) {\n    this.lastLayout = compactGridLayout(\n      this.refreshLayout(dashIdChange),\n      this.compactType,\n      this.cols,\n    );\n  }\n\n  getItemRenderData(itemId: string): GridItemRenderData {\n    return this.gridLayoutService.gridItemsRenderData[itemId];\n  }\n\n  private initSubscriptions() {\n    this.gridItems.changes.pipe(takeUntil(this.destroy$$)).subscribe(() => {\n      const markLayoutIdChange = this.markLayoutIdChange;\n      // need this Raf to make this.lastLayout to be last\n      requestAnimationFrame(() => {\n        this.markLayoutIdChange = false;\n        this.compactLayout(!markLayoutIdChange);\n        this.gridLayoutService.calculateRenderData();\n        this.gridLayoutService.flushRenderData(!markLayoutIdChange);\n      });\n    });\n    this.gridItems.changes\n      .pipe(\n        takeUntil(this.destroy$$),\n        startWith(this.gridItems),\n        switchMap((gridItems: QueryList<GridItemComponent>) =>\n          merge(\n            ...gridItems.map(gridItem =>\n              gridItem.dragStart$.pipe(\n                map(event => ({\n                  event,\n                  gridItem,\n                  type: 'drag' as DragActionType,\n                })),\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              this.ngZone.run(() =>\n                (type === 'drag' ? this.dragStarted : this.resizeStarted).emit(\n                  getDragResizeEventData(gridItem, this.lastLayout),\n                ),\n              );\n              return this.handleAction$(gridItem, event, type).pipe(\n                map(layout => ({ layout, gridItem, type })),\n              );\n            }),\n          ),\n        ),\n      )\n      .subscribe(({ layout, gridItem, type }) => {\n        this.lastLayout = layout;\n        (type === 'drag' ? this.dragEnded : this.resizeEnded).emit(\n          getDragResizeEventData(gridItem, layout),\n        );\n        this.layoutUpdated.emit(layout);\n      });\n  }\n\n  private handleAction$(\n    gridItem: GridItemComponent,\n    pointerDownEvent: MouseEvent,\n    type: DragActionType,\n  ): Observable<GridLayout> {\n    return new Observable<GridLayout>((observer: Observer<GridLayout>) => {\n      // Retrieve grid (parent) and gridItem (draggedElem) client rects.\n      const gridElemClientRectSnapshot: GridItemClientRect =\n        getClientRectSnapshot(this.elementRef.nativeElement as HTMLElement);\n      const dragElemClientRectSnapshot: GridItemClientRect =\n        getClientRectSnapshot(gridItem.elementRef.nativeElement as HTMLElement);\n\n      const scrollableParent =\n        typeof this.scrollableParent === 'string'\n          ? document.querySelector(this.scrollableParent)\n          : this.scrollableParent;\n\n      this.renderer.addClass(\n        gridItem.elementRef.nativeElement,\n        'no-transitions',\n      );\n      this.renderer.addClass(\n        gridItem.elementRef.nativeElement,\n        'grid-item-dragging',\n      );\n\n      const placeholderClientRect: GridItemClientRect = {\n        ...dragElemClientRectSnapshot,\n        left: dragElemClientRectSnapshot.left - gridElemClientRectSnapshot.left,\n        top: dragElemClientRectSnapshot.top - gridElemClientRectSnapshot.top,\n      };\n      this.gridPlaceholderService.createPlaceholderElement(\n        placeholderClientRect,\n        this.elementRef,\n        this.viewContainerRef,\n        gridItem.placeholder,\n      );\n\n      let newLayout: GridLayoutItem[];\n\n      (scrollableParent\n        ? getMouseMove$(this.document.documentElement).pipe(\n            runOutsideZone$(this.ngZone),\n            takeUntil(this.destroy$$),\n            scrollIfNearElementClientRect$(scrollableParent, {\n              scrollStep: this.scrollSpeed,\n            }),\n          )\n        : NEVER\n      )\n        .pipe(takeUntil(getMouseEnd$(this.document.documentElement)))\n        .subscribe();\n      merge(\n        combineLatest([\n          getMouseMove$(this.document.documentElement),\n          this.gridLayoutService.scrollDifference$,\n        ]),\n      )\n        .pipe(\n          runOutsideZone$(this.ngZone),\n          takeUntil(getMouseEnd$(this.document.documentElement)),\n          takeUntil(this.destroy$$),\n        )\n        .subscribe(\n          ([pointerDragEvent, scrollDifference]: [\n            MouseEvent,\n            { top: number; left: number },\n          ]) => {\n            pointerDragEvent.preventDefault();\n            const gridItemId = gridItem.id;\n            const { gridData, layout } =\n              this.gridLayoutService.layoutWhenAction(\n                gridItem,\n                type,\n                {\n                  pointerDownEvent,\n                  pointerDragEvent,\n                },\n                scrollDifference,\n                dragElemClientRectSnapshot,\n                gridElemClientRectSnapshot,\n              );\n            this.gridLayoutService.flushRenderData();\n            newLayout = cloneDeep(layout);\n\n            const newItemGridData = { ...gridData[gridItemId] };\n\n            // put the grid normalize position to the placeholder element\n            this.gridPlaceholderService.updatePlaceHolder(newItemGridData);\n\n            type === 'resize' &&\n              this.gridItemResize.emit({\n                width: newItemGridData.width,\n                height: newItemGridData.height,\n                gridItemRef: getDragResizeEventData(gridItem, newLayout)\n                  .gridItemRef,\n              });\n          },\n          error => observer.error(error),\n          () => {\n            this.ngZone.run(() => {\n              this.renderer.removeClass(\n                gridItem.elementRef.nativeElement,\n                'no-transitions',\n              );\n              this.renderer.removeClass(\n                gridItem.elementRef.nativeElement,\n                'grid-item-dragging',\n              );\n              // when action is done, use another relayout to make sure everything is fine\n              this.compactLayout(false);\n              this.gridLayoutService.calculateRenderData();\n              this.gridLayoutService.flushRenderData();\n\n              this.gridPlaceholderService.destroyPlaceholder();\n              if (newLayout) {\n                observer.next(cloneDeep(newLayout) as GridLayout);\n              }\n              observer.complete();\n            });\n          },\n        );\n    });\n  }\n}\n","<ng-content></ng-content>\n"]}

package/esm2022/grid-layout/components/grid-items/component.mjs

@@ -0,0 +1,228 @@
+import { __decorate, __metadata } from "tslib";
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, ContentChild, ContentChildren, ElementRef, EventEmitter, Inject, Input, NgZone, Output, QueryList, Renderer2, ViewChild, } from '@angular/core';
+import { NEVER, Observable, startWith, switchMap, merge, iif, exhaustMap, take, map, Subject, takeUntil, filter, distinctUntilChanged, } from 'rxjs';
+import { isEqual, ObservableInput } from '../../../public-api';
+import { GRID_DRAG_HANDLER, } from '../../directives/drag-handler.directive';
+import { GridItemPlaceholderDirective, GRID_ITEM_PLACEHOLDER, } from '../../directives/placeholder.directive';
+import { GRID_REMOVE_HANDLER, } from '../../directives/remove-handler.directive';
+import { GRID_RESIZE_HANDLER, } from '../../directives/resize-handler.directive';
+import { GridLayoutService } from '../../grid-layout.service';
+import { parseRenderItemToPixels } from '../../utils/grid.utils';
+import { accessPointerMoveThreshold, getMouseClick$, getMouseDown$, getMouseEnd$, getMouseMove$, } from '../../utils/mouse.utils';
+import { runOutsideZone$ } from '../../utils/operator';
+import * as i0 from "@angular/core";
+import * as i1 from "../../grid-layout.service";
+import * as i2 from "@alauda/ui";
+const _c0 = ["resizeElem"];
+const _c1 = ["removeElem"];
+const _c2 = ["*"];
+const ANIMATION_DURATION_MS = 250;
+export class GridItemComponent {
+    constructor(elementRef, document, renderer, ngZone, layoutService) {
+        this.elementRef = elementRef;
+        this.document = document;
+        this.renderer = renderer;
+        this.ngZone = ngZone;
+        this.layoutService = layoutService;
+        /** CSS transition style */
+        this.transition = `transform ${ANIMATION_DURATION_MS}ms ease, width ${ANIMATION_DURATION_MS}ms ease, height ${ANIMATION_DURATION_MS}ms ease`;
+        /** Minimum amount of pixels that the user should move before it starts the drag sequence. */
+        this.dragStartThreshold = 0;
+        /** Whether the item is draggable or not. Defaults to true. */
+        this.draggable = true;
+        /** Whether the item is resizable or not. Defaults to true. */
+        this.resizable = true;
+        this.removable = true;
+        this.destroy$$ = new Subject();
+        this.dragStartSubject = new Subject();
+        this.resizeStartSubject = new Subject();
+        this.dragStart$ = this.dragStartSubject.asObservable();
+        this.resizeStart$ = this.resizeStartSubject.asObservable();
+        this.remove = new EventEmitter();
+    }
+    ngOnInit() {
+        this.layoutService.gridRenderItemsData$$
+            .pipe(map(({ data, animation }) => ({ data: data?.[this.id], animation })), distinctUntilChanged((a, b) => isEqual(a.data, b.data)), takeUntil(this.destroy$$))
+            .subscribe(({ data, animation }) => {
+            this.setStyles(parseRenderItemToPixels(data), animation);
+        });
+    }
+    ngAfterContentInit() {
+        this.setupDragStartListener();
+        this.setupResizeStartListener();
+        this.setupRemoveListener();
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    setStyles({ top, left, width, height, }, animation) {
+        this.renderer.setStyle(this.elementRef.nativeElement, 'transform', `translateX(${left}) translateY(${top})`);
+        this.renderer.setStyle(this.elementRef.nativeElement, 'transition', animation ? this.transition : 'none');
+        requestAnimationFrame(() => {
+            this.renderer.setStyle(this.elementRef.nativeElement, 'display', `block`);
+            if (width != null) {
+                this.renderer.setStyle(this.elementRef.nativeElement, 'width', width);
+            }
+            if (height != null) {
+                this.renderer.setStyle(this.elementRef.nativeElement, 'height', height);
+            }
+        });
+    }
+    setupDragStartListener() {
+        const document = this.document.documentElement;
+        this.draggable$
+            .pipe(takeUntil(this.destroy$$), startWith(this.draggable), 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 => getMouseDown$(dragHandle.element.nativeElement))), getMouseDown$(this.elementRef.nativeElement)).pipe(exhaustMap(startEvent => {
+                // Prevent browser default drag/drop action, we handle all scenes
+                if (startEvent.target &&
+                    startEvent.target.draggable &&
+                    startEvent.type === 'mousedown') {
+                    startEvent.preventDefault();
+                    startEvent.stopImmediatePropagation();
+                }
+                return getMouseMove$(this.document.documentElement).pipe(takeUntil(getMouseEnd$(document)), runOutsideZone$(this.ngZone), filter(moveEvent => {
+                    moveEvent.preventDefault();
+                    return accessPointerMoveThreshold(startEvent, moveEvent, this.dragStartThreshold);
+                }), take(1), map(() => startEvent));
+            }))));
+        }))
+            .subscribe(this.dragStartSubject);
+    }
+    setupRemoveListener() {
+        this.removable$
+            .pipe(takeUntil(this.destroy$$), startWith(this.removable), switchMap(removable => {
+            if (!removable) {
+                this.renderer.setStyle(this.removeElem.nativeElement, 'display', 'none');
+                return NEVER;
+            }
+            return this.removeHandles.changes.pipe(startWith(this.removeHandles), switchMap((removeHandles) => {
+                if (removeHandles.length > 0) {
+                    this.renderer.setStyle(this.removeElem.nativeElement, 'display', 'none');
+                    return merge(...removeHandles
+                        .toArray()
+                        .map(removeHandle => getMouseClick$(removeHandle.element.nativeElement)));
+                }
+                this.renderer.setStyle(this.removeElem.nativeElement, 'display', 'block');
+                return getMouseDown$(this.removeElem.nativeElement);
+            }));
+        }))
+            .subscribe(evt => {
+            evt.preventDefault();
+            this.remove.emit(this.id);
+        });
+    }
+    setupResizeStartListener() {
+        this.resizable$
+            .pipe(takeUntil(this.destroy$$), startWith(this.resizable), switchMap(resizable => {
+            if (!resizable) {
+                this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'none');
+                return NEVER;
+            }
+            return this.resizeHandles.changes.pipe(startWith(this.resizeHandles), switchMap((resizeHandles) => {
+                if (resizeHandles.length > 0) {
+                    this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'none');
+                    return merge(...resizeHandles
+                        .toArray()
+                        .map(resizeHandle => getMouseDown$(resizeHandle.element.nativeElement)));
+                }
+                this.renderer.setStyle(this.resizeElem.nativeElement, 'display', 'block');
+                return getMouseDown$(this.resizeElem.nativeElement);
+            }));
+        }))
+            .subscribe(this.resizeStartSubject);
+    }
+    static { this.ɵfac = function GridItemComponent_Factory(t) { return new (t || GridItemComponent)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(DOCUMENT), i0.ɵɵdirectiveInject(i0.Renderer2), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i1.GridLayoutService)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: GridItemComponent, selectors: [["acl-grid-item"]], contentQueries: function GridItemComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, GRID_ITEM_PLACEHOLDER, 5);
+            i0.ɵɵcontentQuery(dirIndex, GRID_DRAG_HANDLER, 5);
+            i0.ɵɵcontentQuery(dirIndex, GRID_RESIZE_HANDLER, 5);
+            i0.ɵɵcontentQuery(dirIndex, GRID_REMOVE_HANDLER, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.placeholder = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.dragHandles = _t);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.resizeHandles = _t);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.removeHandles = _t);
+        } }, viewQuery: function GridItemComponent_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(_c0, 7, ElementRef);
+            i0.ɵɵviewQuery(_c1, 7, ElementRef);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.resizeElem = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.removeElem = _t.first);
+        } }, inputs: { id: "id", minW: "minW", minH: "minH", maxW: "maxW", maxH: "maxH", transition: "transition", dragStartThreshold: "dragStartThreshold", draggable: "draggable", resizable: "resizable", removable: "removable" }, outputs: { remove: "remove" }, ngContentSelectors: _c2, decls: 6, vars: 0, consts: [[1, "grid-item-default-resize-icon"], ["resizeElem", ""], [1, "grid-item-default-remove"], ["removeElem", ""], ["icon", "xmark"]], template: function GridItemComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+            i0.ɵɵelement(1, "div", 0, 1);
+            i0.ɵɵelementStart(3, "div", 2, 3);
+            i0.ɵɵelement(5, "aui-icon", 4);
+            i0.ɵɵelementEnd();
+        } }, dependencies: [i2.IconComponent], styles: ["[_nghost-%COMP%]{display:none;position:absolute;z-index:1;overflow:hidden}[_nghost-%COMP%]   div[_ngcontent-%COMP%]{position:absolute;user-select:none;z-index:10}[_nghost-%COMP%]   div.grid-item-default-remove[_ngcontent-%COMP%]{position:absolute;top:12px;right:12px}[_nghost-%COMP%]   div.grid-item-default-remove[_ngcontent-%COMP%]   aui-icon[_ngcontent-%COMP%]{font-size:16px}[_nghost-%COMP%]   div.grid-item-default-remove[_ngcontent-%COMP%]   aui-icon[_ngcontent-%COMP%]:hover{cursor:pointer}[_nghost-%COMP%]   div.grid-item-default-resize-icon[_ngcontent-%COMP%]{cursor:se-resize;width:20px;height:20px;bottom:0;right:0;color:inherit}[_nghost-%COMP%]   div.grid-item-default-resize-icon[_ngcontent-%COMP%]:after{content:\"\";position:absolute;right:8px;bottom:8px;width:12px;height:12px;border-right:2px solid rgb(var(--aui-color-n-4));border-bottom:2px solid rgb(var(--aui-color-n-4))}.display-none[_ngcontent-%COMP%]{display:none!important}"], changeDetection: 0 }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], GridItemComponent.prototype, "draggable$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], GridItemComponent.prototype, "resizable$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], GridItemComponent.prototype, "removable$", void 0);
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(GridItemComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-grid-item', changeDetection: ChangeDetectionStrategy.OnPush, template: "<ng-content></ng-content>\n<div\n  #resizeElem\n  class=\"grid-item-default-resize-icon\"\n></div>\n<div\n  #removeElem\n  class=\"grid-item-default-remove\"\n>\n  <aui-icon icon=\"xmark\"></aui-icon>\n</div>\n", styles: [":host{display:none;position:absolute;z-index:1;overflow:hidden}:host div{position:absolute;user-select:none;z-index:10}:host div.grid-item-default-remove{position:absolute;top:12px;right:12px}:host div.grid-item-default-remove aui-icon{font-size:16px}:host div.grid-item-default-remove aui-icon:hover{cursor:pointer}:host div.grid-item-default-resize-icon{cursor:se-resize;width:20px;height:20px;bottom:0;right:0;color:inherit}:host div.grid-item-default-resize-icon:after{content:\"\";position:absolute;right:8px;bottom:8px;width:12px;height:12px;border-right:2px solid rgb(var(--aui-color-n-4));border-bottom:2px solid rgb(var(--aui-color-n-4))}.display-none{display:none!important}\n"] }]
+    }], function () { return [{ type: i0.ElementRef }, { type: Document, decorators: [{
+                type: Inject,
+                args: [DOCUMENT]
+            }] }, { type: i0.Renderer2 }, { type: i0.NgZone }, { type: i1.GridLayoutService }]; }, { id: [{
+            type: Input
+        }], dragHandles: [{
+            type: ContentChildren,
+            args: [GRID_DRAG_HANDLER, { descendants: true }]
+        }], resizeHandles: [{
+            type: ContentChildren,
+            args: [GRID_RESIZE_HANDLER, { descendants: true }]
+        }], removeHandles: [{
+            type: ContentChildren,
+            args: [GRID_REMOVE_HANDLER, { descendants: true }]
+        }], resizeElem: [{
+            type: ViewChild,
+            args: ['resizeElem', { static: true, read: ElementRef }]
+        }], removeElem: [{
+            type: ViewChild,
+            args: ['removeElem', { static: true, read: ElementRef }]
+        }], placeholder: [{
+            type: ContentChild,
+            args: [GRID_ITEM_PLACEHOLDER]
+        }], minW: [{
+            type: Input
+        }], minH: [{
+            type: Input
+        }], maxW: [{
+            type: Input
+        }], maxH: [{
+            type: Input
+        }], transition: [{
+            type: Input
+        }], dragStartThreshold: [{
+            type: Input
+        }], draggable: [{
+            type: Input
+        }], draggable$: [], resizable: [{
+            type: Input
+        }], resizable$: [], removable: [{
+            type: Input
+        }], removable$: [], remove: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component.js","sourceRoot":"","sources":["../../../../../../../libs/common/src/grid-layout/components/grid-items/component.ts","../../../../../../../libs/common/src/grid-layout/components/grid-items/template.html"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\nimport {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChild,\n  ContentChildren,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Output,\n  QueryList,\n  Renderer2,\n  ViewChild,\n} from '@angular/core';\nimport {\n  NEVER,\n  Observable,\n  startWith,\n  switchMap,\n  merge,\n  iif,\n  exhaustMap,\n  take,\n  map,\n  Subject,\n  takeUntil,\n  filter,\n  distinctUntilChanged,\n} from 'rxjs';\n\nimport { isEqual, ObservableInput } from '../../../public-api';\nimport {\n  GridDragHandlerDirective,\n  GRID_DRAG_HANDLER,\n} from '../../directives/drag-handler.directive';\nimport {\n  GridItemPlaceholderDirective,\n  GRID_ITEM_PLACEHOLDER,\n} from '../../directives/placeholder.directive';\nimport {\n  GridRemoveHandlerDirective,\n  GRID_REMOVE_HANDLER,\n} from '../../directives/remove-handler.directive';\nimport {\n  GridResizeHandlerDirective,\n  GRID_RESIZE_HANDLER,\n} from '../../directives/resize-handler.directive';\nimport { GridLayoutService } from '../../grid-layout.service';\nimport { parseRenderItemToPixels } from '../../utils/grid.utils';\nimport {\n  accessPointerMoveThreshold,\n  getMouseClick$,\n  getMouseDown$,\n  getMouseEnd$,\n  getMouseMove$,\n} from '../../utils/mouse.utils';\nimport { runOutsideZone$ } from '../../utils/operator';\n\nconst ANIMATION_DURATION_MS = 250;\n\n@Component({\n  selector: 'acl-grid-item',\n  templateUrl: './template.html',\n  styleUrls: ['./style.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class GridItemComponent implements OnInit, OnDestroy, AfterContentInit {\n  @Input()\n  id!: string;\n\n  @ContentChildren(GRID_DRAG_HANDLER, { descendants: true })\n  private readonly dragHandles: QueryList<GridDragHandlerDirective>;\n\n  @ContentChildren(GRID_RESIZE_HANDLER, { descendants: true })\n  private readonly resizeHandles: QueryList<GridResizeHandlerDirective>;\n\n  @ContentChildren(GRID_REMOVE_HANDLER, { descendants: true })\n  private readonly removeHandles: QueryList<GridRemoveHandlerDirective>;\n\n  @ViewChild('resizeElem', { static: true, read: ElementRef })\n  resizeElem: ElementRef;\n\n  @ViewChild('removeElem', { static: true, read: ElementRef })\n  removeElem: ElementRef;\n\n  @ContentChild(GRID_ITEM_PLACEHOLDER)\n  placeholder: GridItemPlaceholderDirective;\n\n  @Input() minW?: number;\n  @Input() minH?: number;\n  @Input() maxW?: number;\n  @Input() maxH?: number;\n\n  /** CSS transition style */\n  @Input()\n  transition = `transform ${ANIMATION_DURATION_MS}ms ease, width ${ANIMATION_DURATION_MS}ms ease, height ${ANIMATION_DURATION_MS}ms ease`;\n\n  /** Minimum amount of pixels that the user should move before it starts the drag sequence. */\n  @Input()\n  dragStartThreshold = 0;\n\n  /** Whether the item is draggable or not. Defaults to true. */\n  @Input()\n  draggable = true;\n\n  @ObservableInput()\n  draggable$!: Observable<boolean>;\n\n  /** Whether the item is resizable or not. Defaults to true. */\n  @Input()\n  resizable = true;\n\n  @ObservableInput()\n  resizable$: Observable<boolean>;\n\n  @Input()\n  removable = true;\n\n  @ObservableInput()\n  removable$: Observable<boolean>;\n\n  destroy$$ = new Subject<void>();\n\n  private readonly dragStartSubject = new Subject<MouseEvent>();\n  private readonly resizeStartSubject = new Subject<MouseEvent>();\n\n  dragStart$ = this.dragStartSubject.asObservable();\n  resizeStart$ = this.resizeStartSubject.asObservable();\n\n  constructor(\n    public elementRef: ElementRef,\n    @Inject(DOCUMENT) private readonly document: Document,\n    private readonly renderer: Renderer2,\n    private readonly ngZone: NgZone,\n    private readonly layoutService: GridLayoutService,\n  ) {}\n\n  @Output()\n  remove = new EventEmitter();\n\n  ngOnInit() {\n    this.layoutService.gridRenderItemsData$$\n      .pipe(\n        map(({ data, animation }) => ({ data: data?.[this.id], animation })),\n        distinctUntilChanged((a, b) => isEqual(a.data, b.data)),\n        takeUntil(this.destroy$$),\n      )\n      .subscribe(({ data, animation }) => {\n        this.setStyles(parseRenderItemToPixels(data), animation);\n      });\n  }\n\n  ngAfterContentInit() {\n    this.setupDragStartListener();\n    this.setupResizeStartListener();\n    this.setupRemoveListener();\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  setStyles(\n    {\n      top,\n      left,\n      width,\n      height,\n    }: {\n      top: string;\n      left: string;\n      width?: string;\n      height?: string;\n    },\n    animation: boolean,\n  ) {\n    this.renderer.setStyle(\n      this.elementRef.nativeElement,\n      'transform',\n      `translateX(${left}) translateY(${top})`,\n    );\n\n    this.renderer.setStyle(\n      this.elementRef.nativeElement,\n      'transition',\n      animation ? this.transition : 'none',\n    );\n    requestAnimationFrame(() => {\n      this.renderer.setStyle(this.elementRef.nativeElement, 'display', `block`);\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\n  private setupDragStartListener() {\n    const document = this.document.documentElement;\n    this.draggable$\n      .pipe(\n        takeUntil(this.destroy$$),\n        startWith(this.draggable),\n        switchMap(draggable => {\n          if (!draggable) {\n            return NEVER;\n          }\n          return this.dragHandles.changes.pipe(\n            startWith(this.dragHandles),\n            switchMap((dragHandles: QueryList<GridDragHandlerDirective>) =>\n              iif(\n                () => dragHandles.length > 0,\n                merge(\n                  ...dragHandles\n                    .toArray()\n                    .map(dragHandle =>\n                      getMouseDown$(dragHandle.element.nativeElement),\n                    ),\n                ),\n                getMouseDown$(this.elementRef.nativeElement),\n              ).pipe(\n                exhaustMap(startEvent => {\n                  // Prevent browser default drag/drop action, we handle all scenes\n                  if (\n                    startEvent.target &&\n                    (startEvent.target as HTMLElement).draggable &&\n                    startEvent.type === 'mousedown'\n                  ) {\n                    startEvent.preventDefault();\n                    startEvent.stopImmediatePropagation();\n                  }\n\n                  return getMouseMove$(this.document.documentElement).pipe(\n                    takeUntil(getMouseEnd$(document)),\n                    runOutsideZone$(this.ngZone),\n                    filter(moveEvent => {\n                      moveEvent.preventDefault();\n                      return accessPointerMoveThreshold(\n                        startEvent,\n                        moveEvent,\n                        this.dragStartThreshold,\n                      );\n                    }),\n                    take(1),\n                    map(() => startEvent),\n                  );\n                }),\n              ),\n            ),\n          );\n        }),\n      )\n      .subscribe(this.dragStartSubject);\n  }\n\n  private setupRemoveListener() {\n    this.removable$\n      .pipe(\n        takeUntil(this.destroy$$),\n        startWith(this.removable),\n        switchMap(removable => {\n          if (!removable) {\n            this.renderer.setStyle(\n              this.removeElem.nativeElement,\n              'display',\n              'none',\n            );\n            return NEVER;\n          }\n          return this.removeHandles.changes.pipe(\n            startWith(this.removeHandles),\n            switchMap(\n              (removeHandles: QueryList<GridRemoveHandlerDirective>) => {\n                if (removeHandles.length > 0) {\n                  this.renderer.setStyle(\n                    this.removeElem.nativeElement,\n                    'display',\n                    'none',\n                  );\n\n                  return merge(\n                    ...removeHandles\n                      .toArray()\n                      .map(removeHandle =>\n                        getMouseClick$(removeHandle.element.nativeElement),\n                      ),\n                  );\n                }\n                this.renderer.setStyle(\n                  this.removeElem.nativeElement,\n                  'display',\n                  'block',\n                );\n                return getMouseDown$(this.removeElem.nativeElement);\n              },\n            ),\n          );\n        }),\n      )\n      .subscribe(evt => {\n        evt.preventDefault();\n        this.remove.emit(this.id);\n      });\n  }\n\n  private setupResizeStartListener() {\n    this.resizable$\n      .pipe(\n        takeUntil(this.destroy$$),\n        startWith(this.resizable),\n        switchMap(resizable => {\n          if (!resizable) {\n            this.renderer.setStyle(\n              this.resizeElem.nativeElement,\n              'display',\n              'none',\n            );\n            return NEVER;\n          }\n          return this.resizeHandles.changes.pipe(\n            startWith(this.resizeHandles),\n            switchMap(\n              (resizeHandles: QueryList<GridResizeHandlerDirective>) => {\n                if (resizeHandles.length > 0) {\n                  this.renderer.setStyle(\n                    this.resizeElem.nativeElement,\n                    'display',\n                    'none',\n                  );\n\n                  return merge(\n                    ...resizeHandles\n                      .toArray()\n                      .map(resizeHandle =>\n                        getMouseDown$(resizeHandle.element.nativeElement),\n                      ),\n                  );\n                }\n                this.renderer.setStyle(\n                  this.resizeElem.nativeElement,\n                  'display',\n                  'block',\n                );\n                return getMouseDown$(this.resizeElem.nativeElement);\n              },\n            ),\n          );\n        }),\n      )\n      .subscribe(this.resizeStartSubject);\n  }\n}\n","<ng-content></ng-content>\n<div\n  #resizeElem\n  class=\"grid-item-default-resize-icon\"\n></div>\n<div\n  #removeElem\n  class=\"grid-item-default-remove\"\n>\n  <aui-icon icon=\"xmark\"></aui-icon>\n</div>\n"]}