@ogidor/dashboard 1.0.2 → 1.0.4

package/esm2020/app/custom-grid.component.mjs

@@ -0,0 +1,509 @@
+import { Component, Input, Output, EventEmitter, ViewChild, ContentChild, TemplateRef, Directive, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Directive applied to the template that should be stamped inside each grid cell.
+ * Usage:
+ *   <app-grid [widgets]="...">
+ *     <ng-template gridCell let-widget="widget">
+ *       <app-widget-renderer [widget]="widget" ...></app-widget-renderer>
+ *     </ng-template>
+ *   </app-grid>
+ */
+export class GridCellDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+}
+GridCellDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: GridCellDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+GridCellDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: GridCellDirective, selector: "[gridCell]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: GridCellDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[gridCell]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+class GridEngine {
+    /**
+     * Check if two rects overlap.
+     */
+    static collides(a, b) {
+        return !(a.x + a.cols <= b.x ||
+            b.x + b.cols <= a.x ||
+            a.y + a.rows <= b.y ||
+            b.y + b.rows <= a.y);
+    }
+    /**
+     * Get ALL widgets that collide with `rect`.
+     */
+    static getAllCollisions(widgets, rect) {
+        return widgets.filter(w => w.id !== rect.id && GridEngine.collides(w, rect));
+    }
+    /**
+     * Sort widgets top-to-bottom, left-to-right.
+     */
+    static sortByPosition(widgets) {
+        return [...widgets].sort((a, b) => a.y - b.y || a.x - b.x);
+    }
+    /**
+     * Move a widget to (x, y) and push any colliding widgets downward.
+     * Returns the full list with resolved positions.
+     */
+    static moveWidget(allWidgets, widget, newX, newY, columns) {
+        const widgets = allWidgets.map(w => ({ ...w }));
+        const moving = widgets.find(w => w.id === widget.id);
+        if (!moving)
+            return widgets;
+        moving.x = Math.max(0, Math.min(newX, columns - moving.cols));
+        moving.y = Math.max(0, newY);
+        const sorted = GridEngine.sortByPosition(widgets);
+        GridEngine.resolveCollisions(sorted, moving);
+        return GridEngine.compact(sorted, columns);
+    }
+    /**
+     * Resize a widget and push colliding widgets down.
+     */
+    static resizeWidget(allWidgets, widget, newCols, newRows, columns) {
+        const widgets = allWidgets.map(w => ({ ...w }));
+        const resizing = widgets.find(w => w.id === widget.id);
+        if (!resizing)
+            return widgets;
+        resizing.cols = Math.max(1, Math.min(newCols, columns - resizing.x));
+        resizing.rows = Math.max(1, newRows);
+        const sorted = GridEngine.sortByPosition(widgets);
+        GridEngine.resolveCollisions(sorted, resizing);
+        return GridEngine.compact(sorted, columns);
+    }
+    /**
+     * Push all widgets that collide with `movedWidget` downward, recursively.
+     */
+    static resolveCollisions(widgets, movedWidget) {
+        const collisions = GridEngine.getAllCollisions(widgets, movedWidget);
+        for (const collider of collisions) {
+            collider.y = movedWidget.y + movedWidget.rows;
+            GridEngine.resolveCollisions(widgets, collider);
+        }
+    }
+    /**
+     * Compact the grid: move every widget as far up as possible without overlapping.
+     */
+    static compact(widgets, _columns) {
+        const sorted = GridEngine.sortByPosition(widgets);
+        const placed = [];
+        for (const widget of sorted) {
+            widget.y = GridEngine.findCompactY(placed, widget);
+            placed.push(widget);
+        }
+        return placed;
+    }
+    /**
+     * Find the highest Y position a widget can occupy without overlapping any already-placed widget.
+     */
+    static findCompactY(placed, widget) {
+        let y = 0;
+        while (true) {
+            const test = { ...widget, y };
+            const collision = placed.find(p => GridEngine.collides(p, test));
+            if (!collision)
+                return y;
+            y = collision.y + collision.rows;
+        }
+    }
+    /**
+     * Compute the total number of rows the grid needs.
+     */
+    static getGridHeight(widgets) {
+        if (widgets.length === 0)
+            return 0;
+        return Math.max(...widgets.map(w => w.y + w.rows));
+    }
+}
+/* ═══════════════════════════════════════════════════════════════════════
+   CUSTOM GRID COMPONENT
+   ═══════════════════════════════════════════════════════════════════════ */
+export class CustomGridComponent {
+    constructor(zone, cdr) {
+        this.zone = zone;
+        this.cdr = cdr;
+        this.widgets = [];
+        this.columns = 12;
+        this.gap = 16;
+        this.rowHeight = 80;
+        this.minItemCols = 1;
+        this.minItemRows = 1;
+        this.itemChanged = new EventEmitter();
+        this.layoutChanged = new EventEmitter();
+        this.placeholder = null;
+        this.containerHeight = 400;
+        this.dragging = null;
+        this.resizing = null;
+        this.previewWidgets = [];
+        this.boundMouseMove = this.onMouseMove.bind(this);
+        this.boundMouseUp = this.onMouseUp.bind(this);
+    }
+    ngOnInit() {
+        this.compactAndApply();
+        this.updateContainerHeight();
+        this.zone.runOutsideAngular(() => {
+            window.addEventListener('mousemove', this.boundMouseMove);
+            window.addEventListener('mouseup', this.boundMouseUp);
+        });
+    }
+    ngOnChanges(_changes) {
+        this.updateContainerHeight();
+    }
+    ngOnDestroy() {
+        window.removeEventListener('mousemove', this.boundMouseMove);
+        window.removeEventListener('mouseup', this.boundMouseUp);
+    }
+    trackByFn(_index, item) { return item.id; }
+    // ── Geometry ──
+    get cellWidth() {
+        const containerW = this.gridContainer?.nativeElement?.clientWidth ?? 800;
+        return (containerW - (this.columns - 1) * this.gap) / this.columns;
+    }
+    colToPixel(col) {
+        return col * (this.cellWidth + this.gap);
+    }
+    rowToPixel(row) {
+        return row * (this.rowHeight + this.gap);
+    }
+    pixelToCol(px) {
+        return Math.round(px / (this.cellWidth + this.gap));
+    }
+    pixelToRow(px) {
+        return Math.round(px / (this.rowHeight + this.gap));
+    }
+    colsToPixelWidth(cols) {
+        return cols * this.cellWidth + (cols - 1) * this.gap;
+    }
+    rowsToPixelHeight(rows) {
+        return rows * this.rowHeight + (rows - 1) * this.gap;
+    }
+    getItemLeft(w) {
+        return this.dragging?.id === w.id ? this.dragging.currentPixelX : this.colToPixel(w.x);
+    }
+    getItemTop(w) {
+        return this.dragging?.id === w.id ? this.dragging.currentPixelY : this.rowToPixel(w.y);
+    }
+    getItemWidth(w) {
+        return this.resizing?.id === w.id ? this.resizing.currentPixelW : this.colsToPixelWidth(w.cols);
+    }
+    getItemHeight(w) {
+        return this.resizing?.id === w.id ? this.resizing.currentPixelH : this.rowsToPixelHeight(w.rows);
+    }
+    // ── Drag ──
+    onDragStart(event, widget) {
+        const target = event.target;
+        if (target.closest('button, input, select, textarea, a, .resize-handle'))
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        const rect = this.gridContainer.nativeElement.getBoundingClientRect();
+        const itemLeft = this.colToPixel(widget.x);
+        const itemTop = this.rowToPixel(widget.y);
+        this.dragging = {
+            id: widget.id,
+            offsetX: event.clientX - rect.left - itemLeft,
+            offsetY: event.clientY - rect.top - itemTop,
+            currentPixelX: itemLeft,
+            currentPixelY: itemTop,
+        };
+        this.previewWidgets = this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows }));
+        this.placeholder = {
+            left: itemLeft, top: itemTop,
+            width: this.colsToPixelWidth(widget.cols),
+            height: this.rowsToPixelHeight(widget.rows),
+        };
+        this.cdr.markForCheck();
+    }
+    onResizeStart(event, widget) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.resizing = {
+            id: widget.id,
+            startMouseX: event.clientX,
+            startMouseY: event.clientY,
+            startCols: widget.cols,
+            startRows: widget.rows,
+            currentPixelW: this.colsToPixelWidth(widget.cols),
+            currentPixelH: this.rowsToPixelHeight(widget.rows),
+        };
+        this.previewWidgets = this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows }));
+        this.placeholder = {
+            left: this.colToPixel(widget.x), top: this.rowToPixel(widget.y),
+            width: this.colsToPixelWidth(widget.cols),
+            height: this.rowsToPixelHeight(widget.rows),
+        };
+        this.cdr.markForCheck();
+    }
+    onMouseMove(event) {
+        if (this.dragging)
+            this.handleDragMove(event);
+        else if (this.resizing)
+            this.handleResizeMove(event);
+    }
+    onMouseUp(_event) {
+        if (this.dragging)
+            this.zone.run(() => this.finalizeDrag());
+        else if (this.resizing)
+            this.zone.run(() => this.finalizeResize());
+    }
+    handleDragMove(event) {
+        if (!this.dragging)
+            return;
+        const rect = this.gridContainer.nativeElement.getBoundingClientRect();
+        const widget = this.widgets.find(w => w.id === this.dragging.id);
+        if (!widget)
+            return;
+        let px = event.clientX - rect.left - this.dragging.offsetX;
+        let py = event.clientY - rect.top - this.dragging.offsetY;
+        px = Math.max(0, Math.min(px, rect.width - this.colsToPixelWidth(widget.cols)));
+        py = Math.max(0, py);
+        this.dragging.currentPixelX = px;
+        this.dragging.currentPixelY = py;
+        const targetCol = Math.max(0, Math.min(this.pixelToCol(px), this.columns - widget.cols));
+        const targetRow = Math.max(0, this.pixelToRow(py));
+        const resolved = GridEngine.moveWidget(this.previewWidgets, { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows }, targetCol, targetRow, this.columns);
+        this.placeholder = {
+            left: this.colToPixel(targetCol), top: this.rowToPixel(targetRow),
+            width: this.colsToPixelWidth(widget.cols),
+            height: this.rowsToPixelHeight(widget.rows),
+        };
+        this.zone.run(() => {
+            for (const rw of resolved) {
+                if (rw.id === widget.id)
+                    continue;
+                const w = this.widgets.find(ww => ww.id === rw.id);
+                if (w) {
+                    w.x = rw.x;
+                    w.y = rw.y;
+                }
+            }
+            this.updateContainerHeight();
+            this.cdr.markForCheck();
+        });
+    }
+    finalizeDrag() {
+        if (!this.dragging)
+            return;
+        const widget = this.widgets.find(w => w.id === this.dragging.id);
+        const targetCol = Math.max(0, Math.min(this.pixelToCol(this.dragging.currentPixelX), this.columns - widget.cols));
+        const targetRow = Math.max(0, this.pixelToRow(this.dragging.currentPixelY));
+        const resolved = GridEngine.moveWidget(this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })), { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows }, targetCol, targetRow, this.columns);
+        for (const rw of resolved) {
+            const w = this.widgets.find(ww => ww.id === rw.id);
+            if (w) {
+                w.x = rw.x;
+                w.y = rw.y;
+                w.cols = rw.cols;
+                w.rows = rw.rows;
+                this.itemChanged.emit(w);
+            }
+        }
+        this.dragging = null;
+        this.placeholder = null;
+        this.previewWidgets = [];
+        this.updateContainerHeight();
+        this.layoutChanged.emit(this.widgets);
+        this.cdr.markForCheck();
+    }
+    handleResizeMove(event) {
+        if (!this.resizing)
+            return;
+        const widget = this.widgets.find(w => w.id === this.resizing.id);
+        if (!widget)
+            return;
+        const dx = event.clientX - this.resizing.startMouseX;
+        const dy = event.clientY - this.resizing.startMouseY;
+        let newCols = Math.max(this.minItemCols, Math.round((this.colsToPixelWidth(this.resizing.startCols) + dx) / (this.cellWidth + this.gap)));
+        let newRows = Math.max(this.minItemRows, Math.round((this.rowsToPixelHeight(this.resizing.startRows) + dy) / (this.rowHeight + this.gap)));
+        newCols = Math.min(newCols, this.columns - widget.x);
+        this.resizing.currentPixelW = this.colsToPixelWidth(newCols);
+        this.resizing.currentPixelH = this.rowsToPixelHeight(newRows);
+        const resolved = GridEngine.resizeWidget(this.previewWidgets, { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows }, newCols, newRows, this.columns);
+        this.placeholder = {
+            left: this.colToPixel(widget.x), top: this.rowToPixel(widget.y),
+            width: this.colsToPixelWidth(newCols),
+            height: this.rowsToPixelHeight(newRows),
+        };
+        this.zone.run(() => {
+            for (const rw of resolved) {
+                if (rw.id === widget.id)
+                    continue;
+                const w = this.widgets.find(ww => ww.id === rw.id);
+                if (w) {
+                    w.x = rw.x;
+                    w.y = rw.y;
+                }
+            }
+            this.updateContainerHeight();
+            this.cdr.markForCheck();
+        });
+    }
+    finalizeResize() {
+        if (!this.resizing)
+            return;
+        const widget = this.widgets.find(w => w.id === this.resizing.id);
+        let newCols = Math.max(this.minItemCols, Math.round(this.resizing.currentPixelW / (this.cellWidth + this.gap)));
+        let newRows = Math.max(this.minItemRows, Math.round(this.resizing.currentPixelH / (this.rowHeight + this.gap)));
+        newCols = Math.min(newCols, this.columns - widget.x);
+        const resolved = GridEngine.resizeWidget(this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })), { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows }, newCols, newRows, this.columns);
+        for (const rw of resolved) {
+            const w = this.widgets.find(ww => ww.id === rw.id);
+            if (w) {
+                w.x = rw.x;
+                w.y = rw.y;
+                w.cols = rw.cols;
+                w.rows = rw.rows;
+                this.itemChanged.emit(w);
+            }
+        }
+        this.resizing = null;
+        this.placeholder = null;
+        this.previewWidgets = [];
+        this.updateContainerHeight();
+        this.layoutChanged.emit(this.widgets);
+        this.cdr.markForCheck();
+    }
+    // ── Utilities ──
+    compactAndApply() {
+        if (!this.widgets?.length)
+            return;
+        const compacted = GridEngine.compact(this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })), this.columns);
+        for (const rw of compacted) {
+            const w = this.widgets.find(ww => ww.id === rw.id);
+            if (w) {
+                w.x = rw.x;
+                w.y = rw.y;
+            }
+        }
+    }
+    updateContainerHeight() {
+        if (!this.widgets?.length) {
+            this.containerHeight = 400;
+            return;
+        }
+        const maxRow = GridEngine.getGridHeight(this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })));
+        this.containerHeight = this.rowToPixel(maxRow) + this.rowHeight + this.gap;
+    }
+}
+CustomGridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CustomGridComponent, deps: [{ token: i0.NgZone }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+CustomGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.10", type: CustomGridComponent, selector: "app-grid", inputs: { widgets: "widgets", columns: "columns", gap: "gap", rowHeight: "rowHeight", minItemCols: "minItemCols", minItemRows: "minItemRows" }, outputs: { itemChanged: "itemChanged", layoutChanged: "layoutChanged" }, queries: [{ propertyName: "cellTemplate", first: true, predicate: GridCellDirective, descendants: true, read: TemplateRef }], viewQueries: [{ propertyName: "gridContainer", first: true, predicate: ["gridContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div
+      #gridContainer
+      class="grid-container"
+      [style.height.px]="containerHeight"
+    >
+      <!-- Placeholder preview -->
+      <div
+        class="grid-placeholder"
+        *ngIf="placeholder"
+        [style.left.px]="placeholder.left"
+        [style.top.px]="placeholder.top"
+        [style.width.px]="placeholder.width"
+        [style.height.px]="placeholder.height"
+      ></div>
+
+      <!-- Widget items -->
+      <div
+        *ngFor="let widget of widgets; trackBy: trackByFn"
+        class="grid-item"
+        [class.is-dragging]="dragging?.id === widget.id"
+        [class.is-resizing]="resizing?.id === widget.id"
+        [style.left.px]="getItemLeft(widget)"
+        [style.top.px]="getItemTop(widget)"
+        [style.width.px]="getItemWidth(widget)"
+        [style.height.px]="getItemHeight(widget)"
+        [style.z-index]="(dragging?.id === widget.id || resizing?.id === widget.id) ? 100 : 1"
+        (mousedown)="onDragStart($event, widget)"
+      >
+        <!-- Content stamped from parent template, context carries the widget -->
+        <ng-container
+          *ngIf="cellTemplate"
+          [ngTemplateOutlet]="cellTemplate"
+          [ngTemplateOutletContext]="{ widget: widget }"
+        ></ng-container>
+
+        <!-- Resize handle -->
+        <div class="resize-handle" (mousedown)="onResizeStart($event, widget)">
+          <svg width="12" height="12" viewBox="0 0 12 12">
+            <path d="M11 1v10H1" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+            <path d="M11 5v6H5" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+            <path d="M11 9v2H9" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+          </svg>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, styles: [":host{display:block;width:100%;height:100%}.grid-container{position:relative;width:100%;min-height:100%;transition:height .25s ease}.grid-placeholder{position:absolute;background:var(--dash-accent-color, #0a84ff);opacity:.12;border-radius:24px;border:2px dashed var(--dash-accent-color, #0a84ff);transition:left .15s ease,top .15s ease,width .15s ease,height .15s ease;pointer-events:none;z-index:0}.grid-item{position:absolute;display:flex;flex-direction:column;transition:left .25s ease,top .25s ease,width .25s ease,height .25s ease;border-radius:24px;overflow:hidden}.grid-item.is-dragging,.grid-item.is-resizing{transition:none!important;opacity:.88;overflow:visible;filter:drop-shadow(0 20px 40px rgba(0,0,0,.45))}.resize-handle{position:absolute;right:4px;bottom:4px;width:22px;height:22px;cursor:nwse-resize;display:flex;align-items:center;justify-content:center;color:#ffffff40;border-radius:6px;transition:color .2s,background .2s;z-index:20}.resize-handle:hover{color:var(--dash-accent-color, #0a84ff);background:rgba(255,255,255,.06)}\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: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: CustomGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-grid', template: `
+    <div
+      #gridContainer
+      class="grid-container"
+      [style.height.px]="containerHeight"
+    >
+      <!-- Placeholder preview -->
+      <div
+        class="grid-placeholder"
+        *ngIf="placeholder"
+        [style.left.px]="placeholder.left"
+        [style.top.px]="placeholder.top"
+        [style.width.px]="placeholder.width"
+        [style.height.px]="placeholder.height"
+      ></div>
+
+      <!-- Widget items -->
+      <div
+        *ngFor="let widget of widgets; trackBy: trackByFn"
+        class="grid-item"
+        [class.is-dragging]="dragging?.id === widget.id"
+        [class.is-resizing]="resizing?.id === widget.id"
+        [style.left.px]="getItemLeft(widget)"
+        [style.top.px]="getItemTop(widget)"
+        [style.width.px]="getItemWidth(widget)"
+        [style.height.px]="getItemHeight(widget)"
+        [style.z-index]="(dragging?.id === widget.id || resizing?.id === widget.id) ? 100 : 1"
+        (mousedown)="onDragStart($event, widget)"
+      >
+        <!-- Content stamped from parent template, context carries the widget -->
+        <ng-container
+          *ngIf="cellTemplate"
+          [ngTemplateOutlet]="cellTemplate"
+          [ngTemplateOutletContext]="{ widget: widget }"
+        ></ng-container>
+
+        <!-- Resize handle -->
+        <div class="resize-handle" (mousedown)="onResizeStart($event, widget)">
+          <svg width="12" height="12" viewBox="0 0 12 12">
+            <path d="M11 1v10H1" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+            <path d="M11 5v6H5" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+            <path d="M11 9v2H9" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round"/>
+          </svg>
+        </div>
+      </div>
+    </div>
+  `, changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;width:100%;height:100%}.grid-container{position:relative;width:100%;min-height:100%;transition:height .25s ease}.grid-placeholder{position:absolute;background:var(--dash-accent-color, #0a84ff);opacity:.12;border-radius:24px;border:2px dashed var(--dash-accent-color, #0a84ff);transition:left .15s ease,top .15s ease,width .15s ease,height .15s ease;pointer-events:none;z-index:0}.grid-item{position:absolute;display:flex;flex-direction:column;transition:left .25s ease,top .25s ease,width .25s ease,height .25s ease;border-radius:24px;overflow:hidden}.grid-item.is-dragging,.grid-item.is-resizing{transition:none!important;opacity:.88;overflow:visible;filter:drop-shadow(0 20px 40px rgba(0,0,0,.45))}.resize-handle{position:absolute;right:4px;bottom:4px;width:22px;height:22px;cursor:nwse-resize;display:flex;align-items:center;justify-content:center;color:#ffffff40;border-radius:6px;transition:color .2s,background .2s;z-index:20}.resize-handle:hover{color:var(--dash-accent-color, #0a84ff);background:rgba(255,255,255,.06)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { widgets: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], gap: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], minItemCols: [{
+                type: Input
+            }], minItemRows: [{
+                type: Input
+            }], itemChanged: [{
+                type: Output
+            }], layoutChanged: [{
+                type: Output
+            }], gridContainer: [{
+                type: ViewChild,
+                args: ['gridContainer', { static: true }]
+            }], cellTemplate: [{
+                type: ContentChild,
+                args: [GridCellDirective, { read: TemplateRef }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-grid.component.js","sourceRoot":"","sources":["../../../src/app/custom-grid.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component, Input, Output, EventEmitter, ElementRef,\n  ViewChild, OnDestroy, OnInit, NgZone, ChangeDetectorRef,\n  ContentChild, TemplateRef,\n  Directive, ChangeDetectionStrategy, OnChanges, SimpleChanges\n} from '@angular/core';\nimport { Widget } from './models';\n\n/**\n * Directive applied to the template that should be stamped inside each grid cell.\n * Usage:\n *   <app-grid [widgets]=\"...\">\n *     <ng-template gridCell let-widget=\"widget\">\n *       <app-widget-renderer [widget]=\"widget\" ...></app-widget-renderer>\n *     </ng-template>\n *   </app-grid>\n */\n@Directive({ selector: '[gridCell]' })\nexport class GridCellDirective {\n  constructor(public templateRef: TemplateRef<{ widget: Widget }>) {}\n}\n\n/* ═══════════════════════════════════════════════════════════════════════\n   GRID ENGINE — pure data, zero DOM\n   Handles collision detection, resolution, and compaction.\n   Inspired by react-grid-layout / gridster algorithms.\n   ═══════════════════════════════════════════════════════════════════════ */\n\ninterface GridRect {\n  id: string;\n  x: number;\n  y: number;\n  cols: number;\n  rows: number;\n}\n\nclass GridEngine {\n\n  /**\n   * Check if two rects overlap.\n   */\n  static collides(a: GridRect, b: GridRect): boolean {\n    return !(\n      a.x + a.cols <= b.x ||\n      b.x + b.cols <= a.x ||\n      a.y + a.rows <= b.y ||\n      b.y + b.rows <= a.y\n    );\n  }\n\n  /**\n   * Get ALL widgets that collide with `rect`.\n   */\n  static getAllCollisions(widgets: GridRect[], rect: GridRect): GridRect[] {\n    return widgets.filter(w => w.id !== rect.id && GridEngine.collides(w, rect));\n  }\n\n  /**\n   * Sort widgets top-to-bottom, left-to-right.\n   */\n  static sortByPosition(widgets: GridRect[]): GridRect[] {\n    return [...widgets].sort((a, b) => a.y - b.y || a.x - b.x);\n  }\n\n  /**\n   * Move a widget to (x, y) and push any colliding widgets downward.\n   * Returns the full list with resolved positions.\n   */\n  static moveWidget(\n    allWidgets: GridRect[],\n    widget: GridRect,\n    newX: number,\n    newY: number,\n    columns: number\n  ): GridRect[] {\n    const widgets = allWidgets.map(w => ({ ...w }));\n    const moving = widgets.find(w => w.id === widget.id);\n    if (!moving) return widgets;\n\n    moving.x = Math.max(0, Math.min(newX, columns - moving.cols));\n    moving.y = Math.max(0, newY);\n\n    const sorted = GridEngine.sortByPosition(widgets);\n    GridEngine.resolveCollisions(sorted, moving);\n    return GridEngine.compact(sorted, columns);\n  }\n\n  /**\n   * Resize a widget and push colliding widgets down.\n   */\n  static resizeWidget(\n    allWidgets: GridRect[],\n    widget: GridRect,\n    newCols: number,\n    newRows: number,\n    columns: number\n  ): GridRect[] {\n    const widgets = allWidgets.map(w => ({ ...w }));\n    const resizing = widgets.find(w => w.id === widget.id);\n    if (!resizing) return widgets;\n\n    resizing.cols = Math.max(1, Math.min(newCols, columns - resizing.x));\n    resizing.rows = Math.max(1, newRows);\n\n    const sorted = GridEngine.sortByPosition(widgets);\n    GridEngine.resolveCollisions(sorted, resizing);\n    return GridEngine.compact(sorted, columns);\n  }\n\n  /**\n   * Push all widgets that collide with `movedWidget` downward, recursively.\n   */\n  private static resolveCollisions(widgets: GridRect[], movedWidget: GridRect): void {\n    const collisions = GridEngine.getAllCollisions(widgets, movedWidget);\n    for (const collider of collisions) {\n      collider.y = movedWidget.y + movedWidget.rows;\n      GridEngine.resolveCollisions(widgets, collider);\n    }\n  }\n\n  /**\n   * Compact the grid: move every widget as far up as possible without overlapping.\n   */\n  static compact(widgets: GridRect[], _columns: number): GridRect[] {\n    const sorted = GridEngine.sortByPosition(widgets);\n    const placed: GridRect[] = [];\n\n    for (const widget of sorted) {\n      widget.y = GridEngine.findCompactY(placed, widget);\n      placed.push(widget);\n    }\n\n    return placed;\n  }\n\n  /**\n   * Find the highest Y position a widget can occupy without overlapping any already-placed widget.\n   */\n  private static findCompactY(placed: GridRect[], widget: GridRect): number {\n    let y = 0;\n    while (true) {\n      const test: GridRect = { ...widget, y };\n      const collision = placed.find(p => GridEngine.collides(p, test));\n      if (!collision) return y;\n      y = collision.y + collision.rows;\n    }\n  }\n\n  /**\n   * Compute the total number of rows the grid needs.\n   */\n  static getGridHeight(widgets: GridRect[]): number {\n    if (widgets.length === 0) return 0;\n    return Math.max(...widgets.map(w => w.y + w.rows));\n  }\n}\n\n/* ═══════════════════════════════════════════════════════════════════════\n   CUSTOM GRID COMPONENT\n   ═══════════════════════════════════════════════════════════════════════ */\n\n@Component({\n  selector: 'app-grid',\n  template: `\n    <div\n      #gridContainer\n      class=\"grid-container\"\n      [style.height.px]=\"containerHeight\"\n    >\n      <!-- Placeholder preview -->\n      <div\n        class=\"grid-placeholder\"\n        *ngIf=\"placeholder\"\n        [style.left.px]=\"placeholder.left\"\n        [style.top.px]=\"placeholder.top\"\n        [style.width.px]=\"placeholder.width\"\n        [style.height.px]=\"placeholder.height\"\n      ></div>\n\n      <!-- Widget items -->\n      <div\n        *ngFor=\"let widget of widgets; trackBy: trackByFn\"\n        class=\"grid-item\"\n        [class.is-dragging]=\"dragging?.id === widget.id\"\n        [class.is-resizing]=\"resizing?.id === widget.id\"\n        [style.left.px]=\"getItemLeft(widget)\"\n        [style.top.px]=\"getItemTop(widget)\"\n        [style.width.px]=\"getItemWidth(widget)\"\n        [style.height.px]=\"getItemHeight(widget)\"\n        [style.z-index]=\"(dragging?.id === widget.id || resizing?.id === widget.id) ? 100 : 1\"\n        (mousedown)=\"onDragStart($event, widget)\"\n      >\n        <!-- Content stamped from parent template, context carries the widget -->\n        <ng-container\n          *ngIf=\"cellTemplate\"\n          [ngTemplateOutlet]=\"cellTemplate\"\n          [ngTemplateOutletContext]=\"{ widget: widget }\"\n        ></ng-container>\n\n        <!-- Resize handle -->\n        <div class=\"resize-handle\" (mousedown)=\"onResizeStart($event, widget)\">\n          <svg width=\"12\" height=\"12\" viewBox=\"0 0 12 12\">\n            <path d=\"M11 1v10H1\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>\n            <path d=\"M11 5v6H5\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>\n            <path d=\"M11 9v2H9\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"1.5\" stroke-linecap=\"round\"/>\n          </svg>\n        </div>\n      </div>\n    </div>\n  `,\n  styles: [`\n    :host { display: block; width: 100%; height: 100%; }\n\n    .grid-container {\n      position: relative;\n      width: 100%;\n      min-height: 100%;\n      transition: height 0.25s ease;\n    }\n\n    .grid-placeholder {\n      position: absolute;\n      background: var(--dash-accent-color, #0a84ff);\n      opacity: 0.12;\n      border-radius: 24px;\n      border: 2px dashed var(--dash-accent-color, #0a84ff);\n      transition: left 0.15s ease, top 0.15s ease, width 0.15s ease, height 0.15s ease;\n      pointer-events: none;\n      z-index: 0;\n    }\n\n    .grid-item {\n      position: absolute;\n      display: flex;\n      flex-direction: column;\n      transition: left 0.25s ease, top 0.25s ease, width 0.25s ease, height 0.25s ease;\n      border-radius: 24px;\n      overflow: hidden;\n    }\n\n    .grid-item.is-dragging,\n    .grid-item.is-resizing {\n      transition: none !important;\n      opacity: 0.88;\n      overflow: visible;\n      filter: drop-shadow(0 20px 40px rgba(0,0,0,0.45));\n    }\n\n    /* Resize Handle */\n    .resize-handle {\n      position: absolute;\n      right: 4px;\n      bottom: 4px;\n      width: 22px;\n      height: 22px;\n      cursor: nwse-resize;\n      display: flex;\n      align-items: center;\n      justify-content: center;\n      color: rgba(255,255,255,0.25);\n      border-radius: 6px;\n      transition: color 0.2s, background 0.2s;\n      z-index: 20;\n    }\n    .resize-handle:hover {\n      color: var(--dash-accent-color, #0a84ff);\n      background: rgba(255,255,255,0.06);\n    }\n  `],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class CustomGridComponent implements OnInit, OnDestroy, OnChanges {\n  @Input() widgets: Widget[] = [];\n  @Input() columns: number = 12;\n  @Input() gap: number = 16;\n  @Input() rowHeight: number = 80;\n  @Input() minItemCols: number = 1;\n  @Input() minItemRows: number = 1;\n\n  @Output() itemChanged = new EventEmitter<Widget>();\n  @Output() layoutChanged = new EventEmitter<Widget[]>();\n\n  @ViewChild('gridContainer', { static: true }) gridContainer!: ElementRef<HTMLDivElement>;\n\n  /** The ng-template decorated with gridCell from the parent */\n  @ContentChild(GridCellDirective, { read: TemplateRef }) cellTemplate!: TemplateRef<{ widget: Widget }>;\n\n  placeholder: { left: number; top: number; width: number; height: number } | null = null;\n  containerHeight = 400;\n\n  dragging: {\n    id: string;\n    offsetX: number;\n    offsetY: number;\n    currentPixelX: number;\n    currentPixelY: number;\n  } | null = null;\n\n  resizing: {\n    id: string;\n    startMouseX: number;\n    startMouseY: number;\n    startCols: number;\n    startRows: number;\n    currentPixelW: number;\n    currentPixelH: number;\n  } | null = null;\n\n  private previewWidgets: GridRect[] = [];\n  private boundMouseMove = this.onMouseMove.bind(this);\n  private boundMouseUp = this.onMouseUp.bind(this);\n\n  constructor(private zone: NgZone, private cdr: ChangeDetectorRef) {}\n\n  ngOnInit() {\n    this.compactAndApply();\n    this.updateContainerHeight();\n    this.zone.runOutsideAngular(() => {\n      window.addEventListener('mousemove', this.boundMouseMove);\n      window.addEventListener('mouseup', this.boundMouseUp);\n    });\n  }\n\n  ngOnChanges(_changes: SimpleChanges) {\n    this.updateContainerHeight();\n  }\n\n  ngOnDestroy() {\n    window.removeEventListener('mousemove', this.boundMouseMove);\n    window.removeEventListener('mouseup', this.boundMouseUp);\n  }\n\n  trackByFn(_index: number, item: Widget) { return item.id; }\n\n  // ── Geometry ──\n\n  private get cellWidth(): number {\n    const containerW = this.gridContainer?.nativeElement?.clientWidth ?? 800;\n    return (containerW - (this.columns - 1) * this.gap) / this.columns;\n  }\n\n  private colToPixel(col: number): number {\n    return col * (this.cellWidth + this.gap);\n  }\n\n  private rowToPixel(row: number): number {\n    return row * (this.rowHeight + this.gap);\n  }\n\n  private pixelToCol(px: number): number {\n    return Math.round(px / (this.cellWidth + this.gap));\n  }\n\n  private pixelToRow(px: number): number {\n    return Math.round(px / (this.rowHeight + this.gap));\n  }\n\n  private colsToPixelWidth(cols: number): number {\n    return cols * this.cellWidth + (cols - 1) * this.gap;\n  }\n\n  private rowsToPixelHeight(rows: number): number {\n    return rows * this.rowHeight + (rows - 1) * this.gap;\n  }\n\n  getItemLeft(w: Widget): number {\n    return this.dragging?.id === w.id ? this.dragging.currentPixelX : this.colToPixel(w.x);\n  }\n\n  getItemTop(w: Widget): number {\n    return this.dragging?.id === w.id ? this.dragging.currentPixelY : this.rowToPixel(w.y);\n  }\n\n  getItemWidth(w: Widget): number {\n    return this.resizing?.id === w.id ? this.resizing.currentPixelW : this.colsToPixelWidth(w.cols);\n  }\n\n  getItemHeight(w: Widget): number {\n    return this.resizing?.id === w.id ? this.resizing.currentPixelH : this.rowsToPixelHeight(w.rows);\n  }\n\n  // ── Drag ──\n\n  onDragStart(event: MouseEvent, widget: Widget) {\n    const target = event.target as HTMLElement;\n    if (target.closest('button, input, select, textarea, a, .resize-handle')) return;\n    event.preventDefault();\n    event.stopPropagation();\n\n    const rect = this.gridContainer.nativeElement.getBoundingClientRect();\n    const itemLeft = this.colToPixel(widget.x);\n    const itemTop = this.rowToPixel(widget.y);\n\n    this.dragging = {\n      id: widget.id,\n      offsetX: event.clientX - rect.left - itemLeft,\n      offsetY: event.clientY - rect.top - itemTop,\n      currentPixelX: itemLeft,\n      currentPixelY: itemTop,\n    };\n    this.previewWidgets = this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows }));\n    this.placeholder = {\n      left: itemLeft, top: itemTop,\n      width: this.colsToPixelWidth(widget.cols),\n      height: this.rowsToPixelHeight(widget.rows),\n    };\n    this.cdr.markForCheck();\n  }\n\n  onResizeStart(event: MouseEvent, widget: Widget) {\n    event.preventDefault();\n    event.stopPropagation();\n    this.resizing = {\n      id: widget.id,\n      startMouseX: event.clientX,\n      startMouseY: event.clientY,\n      startCols: widget.cols,\n      startRows: widget.rows,\n      currentPixelW: this.colsToPixelWidth(widget.cols),\n      currentPixelH: this.rowsToPixelHeight(widget.rows),\n    };\n    this.previewWidgets = this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows }));\n    this.placeholder = {\n      left: this.colToPixel(widget.x), top: this.rowToPixel(widget.y),\n      width: this.colsToPixelWidth(widget.cols),\n      height: this.rowsToPixelHeight(widget.rows),\n    };\n    this.cdr.markForCheck();\n  }\n\n  private onMouseMove(event: MouseEvent) {\n    if (this.dragging) this.handleDragMove(event);\n    else if (this.resizing) this.handleResizeMove(event);\n  }\n\n  private onMouseUp(_event: MouseEvent) {\n    if (this.dragging) this.zone.run(() => this.finalizeDrag());\n    else if (this.resizing) this.zone.run(() => this.finalizeResize());\n  }\n\n  private handleDragMove(event: MouseEvent) {\n    if (!this.dragging) return;\n    const rect = this.gridContainer.nativeElement.getBoundingClientRect();\n    const widget = this.widgets.find(w => w.id === this.dragging!.id)!;\n    if (!widget) return;\n\n    let px = event.clientX - rect.left - this.dragging.offsetX;\n    let py = event.clientY - rect.top - this.dragging.offsetY;\n    px = Math.max(0, Math.min(px, rect.width - this.colsToPixelWidth(widget.cols)));\n    py = Math.max(0, py);\n\n    this.dragging.currentPixelX = px;\n    this.dragging.currentPixelY = py;\n\n    const targetCol = Math.max(0, Math.min(this.pixelToCol(px), this.columns - widget.cols));\n    const targetRow = Math.max(0, this.pixelToRow(py));\n\n    const resolved = GridEngine.moveWidget(\n      this.previewWidgets,\n      { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows },\n      targetCol, targetRow, this.columns\n    );\n\n    this.placeholder = {\n      left: this.colToPixel(targetCol), top: this.rowToPixel(targetRow),\n      width: this.colsToPixelWidth(widget.cols),\n      height: this.rowsToPixelHeight(widget.rows),\n    };\n\n    this.zone.run(() => {\n      for (const rw of resolved) {\n        if (rw.id === widget.id) continue;\n        const w = this.widgets.find(ww => ww.id === rw.id);\n        if (w) { w.x = rw.x; w.y = rw.y; }\n      }\n      this.updateContainerHeight();\n      this.cdr.markForCheck();\n    });\n  }\n\n  private finalizeDrag() {\n    if (!this.dragging) return;\n    const widget = this.widgets.find(w => w.id === this.dragging!.id)!;\n    const targetCol = Math.max(0, Math.min(this.pixelToCol(this.dragging.currentPixelX), this.columns - widget.cols));\n    const targetRow = Math.max(0, this.pixelToRow(this.dragging.currentPixelY));\n\n    const resolved = GridEngine.moveWidget(\n      this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })),\n      { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows },\n      targetCol, targetRow, this.columns\n    );\n    for (const rw of resolved) {\n      const w = this.widgets.find(ww => ww.id === rw.id);\n      if (w) { w.x = rw.x; w.y = rw.y; w.cols = rw.cols; w.rows = rw.rows; this.itemChanged.emit(w); }\n    }\n    this.dragging = null;\n    this.placeholder = null;\n    this.previewWidgets = [];\n    this.updateContainerHeight();\n    this.layoutChanged.emit(this.widgets);\n    this.cdr.markForCheck();\n  }\n\n  private handleResizeMove(event: MouseEvent) {\n    if (!this.resizing) return;\n    const widget = this.widgets.find(w => w.id === this.resizing!.id)!;\n    if (!widget) return;\n\n    const dx = event.clientX - this.resizing.startMouseX;\n    const dy = event.clientY - this.resizing.startMouseY;\n\n    let newCols = Math.max(this.minItemCols, Math.round((this.colsToPixelWidth(this.resizing.startCols) + dx) / (this.cellWidth + this.gap)));\n    let newRows = Math.max(this.minItemRows, Math.round((this.rowsToPixelHeight(this.resizing.startRows) + dy) / (this.rowHeight + this.gap)));\n    newCols = Math.min(newCols, this.columns - widget.x);\n\n    this.resizing.currentPixelW = this.colsToPixelWidth(newCols);\n    this.resizing.currentPixelH = this.rowsToPixelHeight(newRows);\n\n    const resolved = GridEngine.resizeWidget(\n      this.previewWidgets,\n      { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows },\n      newCols, newRows, this.columns\n    );\n\n    this.placeholder = {\n      left: this.colToPixel(widget.x), top: this.rowToPixel(widget.y),\n      width: this.colsToPixelWidth(newCols),\n      height: this.rowsToPixelHeight(newRows),\n    };\n\n    this.zone.run(() => {\n      for (const rw of resolved) {\n        if (rw.id === widget.id) continue;\n        const w = this.widgets.find(ww => ww.id === rw.id);\n        if (w) { w.x = rw.x; w.y = rw.y; }\n      }\n      this.updateContainerHeight();\n      this.cdr.markForCheck();\n    });\n  }\n\n  private finalizeResize() {\n    if (!this.resizing) return;\n    const widget = this.widgets.find(w => w.id === this.resizing!.id)!;\n\n    let newCols = Math.max(this.minItemCols, Math.round(this.resizing.currentPixelW / (this.cellWidth + this.gap)));\n    let newRows = Math.max(this.minItemRows, Math.round(this.resizing.currentPixelH / (this.rowHeight + this.gap)));\n    newCols = Math.min(newCols, this.columns - widget.x);\n\n    const resolved = GridEngine.resizeWidget(\n      this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })),\n      { id: widget.id, x: widget.x, y: widget.y, cols: widget.cols, rows: widget.rows },\n      newCols, newRows, this.columns\n    );\n    for (const rw of resolved) {\n      const w = this.widgets.find(ww => ww.id === rw.id);\n      if (w) { w.x = rw.x; w.y = rw.y; w.cols = rw.cols; w.rows = rw.rows; this.itemChanged.emit(w); }\n    }\n    this.resizing = null;\n    this.placeholder = null;\n    this.previewWidgets = [];\n    this.updateContainerHeight();\n    this.layoutChanged.emit(this.widgets);\n    this.cdr.markForCheck();\n  }\n\n  // ── Utilities ──\n\n  private compactAndApply() {\n    if (!this.widgets?.length) return;\n    const compacted = GridEngine.compact(\n      this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows })),\n      this.columns\n    );\n    for (const rw of compacted) {\n      const w = this.widgets.find(ww => ww.id === rw.id);\n      if (w) { w.x = rw.x; w.y = rw.y; }\n    }\n  }\n\n  private updateContainerHeight() {\n    if (!this.widgets?.length) { this.containerHeight = 400; return; }\n    const maxRow = GridEngine.getGridHeight(\n      this.widgets.map(w => ({ id: w.id, x: w.x, y: w.y, cols: w.cols, rows: w.rows }))\n    );\n    this.containerHeight = this.rowToPixel(maxRow) + this.rowHeight + this.gap;\n  }\n}\n"]}