pdm-ui-kit 0.1.50 → 0.2.0

package/esm2020/lib/components/draggable-table/draggable-table.component.mjs

@@ -0,0 +1,300 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Tabla con funcionalidad de reordenamiento de filas mediante drag & drop
+ *
+ * Extiende pdm-table agregando la capacidad de reordenar filas.
+ * Si no necesitás drag & drop, usá pdm-table directamente (más simple y liviano).
+ *
+ * @example
+ * <pdm-draggable-table
+ *   variant="interactive"
+ *   [reorderRows]="true"
+ *   (rowOrderChange)="onOrderChange($event)">
+ *   <tbody>
+ *     <tr data-row-id="1"><td>Row 1</td></tr>
+ *     <tr data-row-id="2"><td>Row 2</td></tr>
+ *   </tbody>
+ * </pdm-draggable-table>
+ *
+ * IMPORTANTE: Cada <tr> debe tener un atributo data-row-id único
+ */
+export class PdmDraggableTableComponent {
+    constructor(renderer) {
+        this.renderer = renderer;
+        this.variant = 'default';
+        this.responsiveStrategy = 'scroll';
+        this.className = '';
+        this.fullBleed = false;
+        /**
+         * Habilita el reordenamiento de filas mediante drag & drop
+         */
+        this.reorderRows = false;
+        /**
+         * Selector CSS para identificar los handles de drag
+         * Por defecto busca: [data-drag-handle], [data-slot=row-drag-handle], .row-drag-handle
+         * Si no encuentra ninguno, inserta un handle automático
+         */
+        this.dragHandleSelector = '[data-drag-handle],[data-slot=row-drag-handle],.row-drag-handle,[data-auto-drag-handle]';
+        /**
+         * Emite el nuevo orden de las filas cuando el usuario termina de arrastrar
+         * Array de data-row-id en el nuevo orden
+         */
+        this.rowOrderChange = new EventEmitter();
+        this.cleanupListeners = [];
+        this.draggedRow = null;
+    }
+    ngAfterViewInit() {
+        this.syncReorderBehavior();
+    }
+    // Getters para clases CSS (mismo comportamiento que pdm-table)
+    get wrapperClasses() {
+        const baseClasses = ['relative', 'w-full'];
+        const strategyClasses = this.getResponsiveStrategyClasses();
+        const variantClasses = this.getVariantWrapperClasses();
+        if (this.fullBleed && this.responsiveStrategy === 'scroll') {
+            baseClasses.push('-mx-4', 'px-4', 'sm:mx-0', 'sm:px-0');
+        }
+        return [
+            ...baseClasses,
+            ...strategyClasses,
+            ...variantClasses,
+            this.className
+        ].filter(Boolean);
+    }
+    get tableClasses() {
+        const baseClasses = ['w-full', 'caption-bottom', 'text-sm'];
+        const variantClasses = this.getVariantTableClasses();
+        const cellClasses = this.getCellClasses();
+        return [...baseClasses, ...variantClasses, ...cellClasses].filter(Boolean);
+    }
+    getResponsiveStrategyClasses() {
+        if (this.responsiveStrategy === 'scroll' || this.responsiveStrategy === 'wrap' || this.responsiveStrategy === 'collapse') {
+            return ['overflow-x-auto'];
+        }
+        return [];
+    }
+    getVariantWrapperClasses() {
+        if (this.variant === 'interactive') {
+            return ['rounded-xl', 'border', 'border-border', 'bg-background'];
+        }
+        if (this.variant === 'data') {
+            return ['rounded-md', 'border', 'border-border', 'bg-background'];
+        }
+        return [];
+    }
+    getVariantTableClasses() {
+        if (this.variant === 'data') {
+            return [
+                'border-collapse', 'text-foreground',
+                '[&_thead_tr]:border-b', '[&_thead_tr]:border-border',
+                '[&_tbody_tr]:border-b', '[&_tbody_tr]:border-border',
+                '[&_tbody_tr:last-child]:border-b-0',
+                '[&_th]:h-10', '[&_th]:px-2', '[&_th]:text-left', '[&_th]:align-middle', '[&_th]:font-medium',
+                '[&_td]:p-2', '[&_td]:align-middle'
+            ];
+        }
+        if (this.variant === 'interactive') {
+            return [
+                'text-foreground',
+                '[&_thead]:sticky', '[&_thead]:top-0', '[&_thead]:z-10', '[&_thead]:bg-muted/70',
+                '[&_thead_tr]:border-b', '[&_thead_tr]:border-border',
+                '[&_th]:h-12', '[&_th]:px-4', '[&_th]:text-left', '[&_th]:align-middle', '[&_th]:text-sm', '[&_th]:font-medium',
+                '[&_tbody_tr]:border-b', '[&_tbody_tr]:border-border',
+                '[&_tbody_tr]:transition-colors', '[&_tbody_tr:hover]:bg-muted/50',
+                '[&_tbody_tr:last-child]:border-b-0',
+                '[&_td]:h-14', '[&_td]:px-4', '[&_td]:align-middle', '[&_td]:text-sm',
+                '[&_svg]:text-muted-foreground'
+            ];
+        }
+        return [];
+    }
+    getCellClasses() {
+        if (this.responsiveStrategy === 'scroll') {
+            return ['[&_td]:whitespace-normal', '[&_th]:whitespace-normal', 'sm:[&_td]:whitespace-nowrap', 'sm:[&_th]:whitespace-nowrap'];
+        }
+        if (this.responsiveStrategy === 'wrap') {
+            return ['[&_td]:whitespace-normal', '[&_td]:break-words', '[&_th]:whitespace-normal'];
+        }
+        return [];
+    }
+    ngOnChanges(changes) {
+        if (changes['reorderRows'] || changes['variant']) {
+            this.syncReorderBehavior();
+        }
+    }
+    ngOnDestroy() {
+        this.cleanupReorderBehavior();
+    }
+    syncReorderBehavior() {
+        this.cleanupReorderBehavior();
+        if (!this.reorderRows) {
+            return;
+        }
+        const tbody = this.getTbody();
+        if (!tbody) {
+            return;
+        }
+        this.setRowsDraggable(tbody, true);
+        this.cleanupListeners.push(this.renderer.listen(tbody, 'mousedown', (event) => this.armDragFromHandle(event)), this.renderer.listen(tbody, 'dragstart', (event) => this.onDragStart(event)), this.renderer.listen(tbody, 'dragover', (event) => this.onDragOver(event, tbody)), this.renderer.listen(tbody, 'drop', (event) => this.onDrop(event)), this.renderer.listen(tbody, 'dragend', () => this.onDragEnd()));
+        // Observer para detectar cambios en el DOM (filas agregadas/removidas)
+        this.observer = new MutationObserver(() => this.setRowsDraggable(tbody, true));
+        this.observer.observe(tbody, { childList: true });
+    }
+    cleanupReorderBehavior() {
+        this.cleanupListeners.forEach((dispose) => dispose());
+        this.cleanupListeners = [];
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = undefined;
+        }
+        const tbody = this.getTbody();
+        if (tbody) {
+            this.setRowsDraggable(tbody, false);
+        }
+        this.draggedRow = null;
+    }
+    getTbody() {
+        return this.tableElement?.nativeElement.tBodies.item(0) ?? null;
+    }
+    setRowsDraggable(tbody, enabled) {
+        const rows = Array.from(tbody.rows);
+        rows.forEach((row) => {
+            this.syncAutoDragHandle(row, enabled);
+            row.draggable = false;
+            if (!enabled) {
+                delete row.dataset['dragging'];
+                delete row.dataset['dragArmed'];
+            }
+        });
+    }
+    /**
+     * Inserta un handle de drag automático si no existe uno custom
+     */
+    syncAutoDragHandle(row, enabled) {
+        const firstCell = row.cells.item(0);
+        if (!firstCell) {
+            return;
+        }
+        const existingAutoHandle = firstCell.querySelector('[data-auto-drag-handle]');
+        if (!enabled) {
+            existingAutoHandle?.remove();
+            return;
+        }
+        const hasCustomHandle = !!firstCell.querySelector('[data-drag-handle],[data-slot=row-drag-handle],.row-drag-handle');
+        if (hasCustomHandle || existingAutoHandle) {
+            return;
+        }
+        // Crear handle automático
+        const button = this.renderer.createElement('button');
+        this.renderer.setAttribute(button, 'type', 'button');
+        this.renderer.setAttribute(button, 'aria-label', 'Drag row');
+        this.renderer.setAttribute(button, 'data-auto-drag-handle', 'true');
+        this.renderer.addClass(button, 'inline-flex');
+        this.renderer.addClass(button, 'h-7');
+        this.renderer.addClass(button, 'w-7');
+        this.renderer.addClass(button, 'items-center');
+        this.renderer.addClass(button, 'justify-center');
+        this.renderer.addClass(button, 'cursor-grab');
+        this.renderer.addClass(button, 'active:cursor-grabbing');
+        this.renderer.addClass(button, 'text-muted-foreground');
+        const dots = this.renderer.createElement('span');
+        this.renderer.addClass(dots, 'text-sm');
+        this.renderer.addClass(dots, 'leading-none');
+        this.renderer.setProperty(dots, 'textContent', '⋮⋮');
+        this.renderer.appendChild(button, dots);
+        this.renderer.insertBefore(firstCell, button, firstCell.firstChild);
+    }
+    onDragStart(event) {
+        const target = event.target;
+        const row = target?.closest('tr');
+        if (!row) {
+            return;
+        }
+        const handle = target?.closest(this.dragHandleSelector);
+        const isArmed = row.dataset['dragArmed'] === 'true';
+        if ((!handle || !row.contains(handle)) && !isArmed) {
+            event.preventDefault();
+            return;
+        }
+        this.draggedRow = row;
+        this.draggedRow.dataset['dragging'] = 'true';
+        if (event.dataTransfer) {
+            event.dataTransfer.effectAllowed = 'move';
+            event.dataTransfer.setData('text/plain', '');
+        }
+    }
+    onDragOver(event, tbody) {
+        if (!this.draggedRow) {
+            return;
+        }
+        event.preventDefault();
+        const target = event.target;
+        const targetRow = target?.closest('tr');
+        if (!targetRow || targetRow === this.draggedRow) {
+            return;
+        }
+        const rect = targetRow.getBoundingClientRect();
+        const shouldInsertBefore = event.clientY < rect.top + rect.height / 2;
+        tbody.insertBefore(this.draggedRow, shouldInsertBefore ? targetRow : targetRow.nextSibling);
+    }
+    onDrop(event) {
+        event.preventDefault();
+    }
+    onDragEnd() {
+        const tbody = this.getTbody();
+        if (tbody) {
+            Array.from(tbody.rows).forEach((row) => {
+                row.draggable = false;
+                delete row.dataset['dragArmed'];
+            });
+        }
+        if (this.draggedRow) {
+            delete this.draggedRow.dataset['dragging'];
+            this.draggedRow = null;
+        }
+        if (!tbody) {
+            return;
+        }
+        const order = Array.from(tbody.rows).map((row, index) => row.getAttribute('data-row-id') || String(index));
+        this.rowOrderChange.emit(order);
+    }
+    armDragFromHandle(event) {
+        const target = event.target;
+        const handle = target?.closest(this.dragHandleSelector);
+        if (!handle) {
+            return;
+        }
+        const row = handle.closest('tr');
+        if (!row) {
+            return;
+        }
+        row.draggable = true;
+        row.dataset['dragArmed'] = 'true';
+    }
+}
+PdmDraggableTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmDraggableTableComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+PdmDraggableTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: PdmDraggableTableComponent, selector: "pdm-draggable-table", inputs: { variant: "variant", responsiveStrategy: "responsiveStrategy", className: "className", fullBleed: "fullBleed", reorderRows: "reorderRows", dragHandleSelector: "dragHandleSelector" }, outputs: { rowOrderChange: "rowOrderChange" }, viewQueries: [{ propertyName: "tableElement", first: true, predicate: ["tableElement"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<div [ngClass]=\"wrapperClasses\" [attr.data-slot]=\"variant === 'interactive' ? 'table-container' : null\">\n  <table #tableElement [ngClass]=\"tableClasses\" [attr.data-slot]=\"variant === 'interactive' ? 'table' : null\">\n    <ng-content></ng-content>\n  </table>\n</div>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmDraggableTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'pdm-draggable-table', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div [ngClass]=\"wrapperClasses\" [attr.data-slot]=\"variant === 'interactive' ? 'table-container' : null\">\n  <table #tableElement [ngClass]=\"tableClasses\" [attr.data-slot]=\"variant === 'interactive' ? 'table' : null\">\n    <ng-content></ng-content>\n  </table>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { variant: [{
+                type: Input
+            }], responsiveStrategy: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], fullBleed: [{
+                type: Input
+            }], reorderRows: [{
+                type: Input
+            }], dragHandleSelector: [{
+                type: Input
+            }], rowOrderChange: [{
+                type: Output
+            }], tableElement: [{
+                type: ViewChild,
+                args: ['tableElement']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"draggable-table.component.js","sourceRoot":"","sources":["../../../../../../src/lib/components/draggable-table/draggable-table.component.ts","../../../../../../src/lib/components/draggable-table/draggable-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  Renderer2,\n  SimpleChanges,\n  ViewChild\n} from '@angular/core';\nimport { PdmTableVariant } from '../table/table.component';\nimport { TableResponsiveStrategy } from '../../utils/responsive';\n\n/**\n * Tabla con funcionalidad de reordenamiento de filas mediante drag & drop\n * \n * Extiende pdm-table agregando la capacidad de reordenar filas.\n * Si no necesitás drag & drop, usá pdm-table directamente (más simple y liviano).\n * \n * @example\n * <pdm-draggable-table \n *   variant=\"interactive\"\n *   [reorderRows]=\"true\"\n *   (rowOrderChange)=\"onOrderChange($event)\">\n *   <tbody>\n *     <tr data-row-id=\"1\"><td>Row 1</td></tr>\n *     <tr data-row-id=\"2\"><td>Row 2</td></tr>\n *   </tbody>\n * </pdm-draggable-table>\n * \n * IMPORTANTE: Cada <tr> debe tener un atributo data-row-id único\n */\n@Component({\n  selector: 'pdm-draggable-table',\n  templateUrl: './draggable-table.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class PdmDraggableTableComponent implements AfterViewInit, OnChanges, OnDestroy {\n  @Input() variant: PdmTableVariant = 'default';\n  @Input() responsiveStrategy: TableResponsiveStrategy = 'scroll';\n  @Input() className = '';\n  @Input() fullBleed = false;\n  \n  /**\n   * Habilita el reordenamiento de filas mediante drag & drop\n   */\n  @Input() reorderRows = false;\n  \n  /**\n   * Selector CSS para identificar los handles de drag\n   * Por defecto busca: [data-drag-handle], [data-slot=row-drag-handle], .row-drag-handle\n   * Si no encuentra ninguno, inserta un handle automático\n   */\n  @Input() dragHandleSelector = '[data-drag-handle],[data-slot=row-drag-handle],.row-drag-handle,[data-auto-drag-handle]';\n  \n  /**\n   * Emite el nuevo orden de las filas cuando el usuario termina de arrastrar\n   * Array de data-row-id en el nuevo orden\n   */\n  @Output() rowOrderChange = new EventEmitter<string[]>();\n\n  @ViewChild('tableElement') tableElement?: ElementRef<HTMLTableElement>;\n\n  private cleanupListeners: Array<() => void> = [];\n  private observer?: MutationObserver;\n  private draggedRow: HTMLTableRowElement | null = null;\n\n  constructor(private readonly renderer: Renderer2) {}\n\n  ngAfterViewInit(): void {\n    this.syncReorderBehavior();\n  }\n\n  // Getters para clases CSS (mismo comportamiento que pdm-table)\n  get wrapperClasses(): string[] {\n    const baseClasses = ['relative', 'w-full'];\n    const strategyClasses = this.getResponsiveStrategyClasses();\n    const variantClasses = this.getVariantWrapperClasses();\n    \n    if (this.fullBleed && this.responsiveStrategy === 'scroll') {\n      baseClasses.push('-mx-4', 'px-4', 'sm:mx-0', 'sm:px-0');\n    }\n    \n    return [\n      ...baseClasses,\n      ...strategyClasses,\n      ...variantClasses,\n      this.className\n    ].filter(Boolean);\n  }\n\n  get tableClasses(): string[] {\n    const baseClasses = ['w-full', 'caption-bottom', 'text-sm'];\n    const variantClasses = this.getVariantTableClasses();\n    const cellClasses = this.getCellClasses();\n    \n    return [...baseClasses, ...variantClasses, ...cellClasses].filter(Boolean);\n  }\n\n  private getResponsiveStrategyClasses(): string[] {\n    if (this.responsiveStrategy === 'scroll' || this.responsiveStrategy === 'wrap' || this.responsiveStrategy === 'collapse') {\n      return ['overflow-x-auto'];\n    }\n    return [];\n  }\n\n  private getVariantWrapperClasses(): string[] {\n    if (this.variant === 'interactive') {\n      return ['rounded-xl', 'border', 'border-border', 'bg-background'];\n    }\n    if (this.variant === 'data') {\n      return ['rounded-md', 'border', 'border-border', 'bg-background'];\n    }\n    return [];\n  }\n\n  private getVariantTableClasses(): string[] {\n    if (this.variant === 'data') {\n      return [\n        'border-collapse', 'text-foreground',\n        '[&_thead_tr]:border-b', '[&_thead_tr]:border-border',\n        '[&_tbody_tr]:border-b', '[&_tbody_tr]:border-border',\n        '[&_tbody_tr:last-child]:border-b-0',\n        '[&_th]:h-10', '[&_th]:px-2', '[&_th]:text-left', '[&_th]:align-middle', '[&_th]:font-medium',\n        '[&_td]:p-2', '[&_td]:align-middle'\n      ];\n    }\n    \n    if (this.variant === 'interactive') {\n      return [\n        'text-foreground',\n        '[&_thead]:sticky', '[&_thead]:top-0', '[&_thead]:z-10', '[&_thead]:bg-muted/70',\n        '[&_thead_tr]:border-b', '[&_thead_tr]:border-border',\n        '[&_th]:h-12', '[&_th]:px-4', '[&_th]:text-left', '[&_th]:align-middle', '[&_th]:text-sm', '[&_th]:font-medium',\n        '[&_tbody_tr]:border-b', '[&_tbody_tr]:border-border',\n        '[&_tbody_tr]:transition-colors', '[&_tbody_tr:hover]:bg-muted/50',\n        '[&_tbody_tr:last-child]:border-b-0',\n        '[&_td]:h-14', '[&_td]:px-4', '[&_td]:align-middle', '[&_td]:text-sm',\n        '[&_svg]:text-muted-foreground'\n      ];\n    }\n    \n    return [];\n  }\n\n  private getCellClasses(): string[] {\n    if (this.responsiveStrategy === 'scroll') {\n      return ['[&_td]:whitespace-normal', '[&_th]:whitespace-normal', 'sm:[&_td]:whitespace-nowrap', 'sm:[&_th]:whitespace-nowrap'];\n    }\n    if (this.responsiveStrategy === 'wrap') {\n      return ['[&_td]:whitespace-normal', '[&_td]:break-words', '[&_th]:whitespace-normal'];\n    }\n    return [];\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['reorderRows'] || changes['variant']) {\n      this.syncReorderBehavior();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.cleanupReorderBehavior();\n  }\n\n  private syncReorderBehavior(): void {\n    this.cleanupReorderBehavior();\n\n    if (!this.reorderRows) {\n      return;\n    }\n\n    const tbody = this.getTbody();\n    if (!tbody) {\n      return;\n    }\n\n    this.setRowsDraggable(tbody, true);\n\n    this.cleanupListeners.push(\n      this.renderer.listen(tbody, 'mousedown', (event: MouseEvent) => this.armDragFromHandle(event)),\n      this.renderer.listen(tbody, 'dragstart', (event: DragEvent) => this.onDragStart(event)),\n      this.renderer.listen(tbody, 'dragover', (event: DragEvent) => this.onDragOver(event, tbody)),\n      this.renderer.listen(tbody, 'drop', (event: DragEvent) => this.onDrop(event)),\n      this.renderer.listen(tbody, 'dragend', () => this.onDragEnd())\n    );\n\n    // Observer para detectar cambios en el DOM (filas agregadas/removidas)\n    this.observer = new MutationObserver(() => this.setRowsDraggable(tbody, true));\n    this.observer.observe(tbody, { childList: true });\n  }\n\n  private cleanupReorderBehavior(): void {\n    this.cleanupListeners.forEach((dispose) => dispose());\n    this.cleanupListeners = [];\n\n    if (this.observer) {\n      this.observer.disconnect();\n      this.observer = undefined;\n    }\n\n    const tbody = this.getTbody();\n    if (tbody) {\n      this.setRowsDraggable(tbody, false);\n    }\n\n    this.draggedRow = null;\n  }\n\n  private getTbody(): HTMLTableSectionElement | null {\n    return this.tableElement?.nativeElement.tBodies.item(0) ?? null;\n  }\n\n  private setRowsDraggable(tbody: HTMLTableSectionElement, enabled: boolean): void {\n    const rows = Array.from(tbody.rows);\n    rows.forEach((row) => {\n      this.syncAutoDragHandle(row, enabled);\n      row.draggable = false;\n      if (!enabled) {\n        delete row.dataset['dragging'];\n        delete row.dataset['dragArmed'];\n      }\n    });\n  }\n\n  /**\n   * Inserta un handle de drag automático si no existe uno custom\n   */\n  private syncAutoDragHandle(row: HTMLTableRowElement, enabled: boolean): void {\n    const firstCell = row.cells.item(0);\n    if (!firstCell) {\n      return;\n    }\n\n    const existingAutoHandle = firstCell.querySelector('[data-auto-drag-handle]');\n    if (!enabled) {\n      existingAutoHandle?.remove();\n      return;\n    }\n\n    const hasCustomHandle = !!firstCell.querySelector('[data-drag-handle],[data-slot=row-drag-handle],.row-drag-handle');\n    if (hasCustomHandle || existingAutoHandle) {\n      return;\n    }\n\n    // Crear handle automático\n    const button = this.renderer.createElement('button') as HTMLButtonElement;\n    this.renderer.setAttribute(button, 'type', 'button');\n    this.renderer.setAttribute(button, 'aria-label', 'Drag row');\n    this.renderer.setAttribute(button, 'data-auto-drag-handle', 'true');\n    this.renderer.addClass(button, 'inline-flex');\n    this.renderer.addClass(button, 'h-7');\n    this.renderer.addClass(button, 'w-7');\n    this.renderer.addClass(button, 'items-center');\n    this.renderer.addClass(button, 'justify-center');\n    this.renderer.addClass(button, 'cursor-grab');\n    this.renderer.addClass(button, 'active:cursor-grabbing');\n    this.renderer.addClass(button, 'text-muted-foreground');\n\n    const dots = this.renderer.createElement('span');\n    this.renderer.addClass(dots, 'text-sm');\n    this.renderer.addClass(dots, 'leading-none');\n    this.renderer.setProperty(dots, 'textContent', '⋮⋮');\n    this.renderer.appendChild(button, dots);\n\n    this.renderer.insertBefore(firstCell, button, firstCell.firstChild);\n  }\n\n  private onDragStart(event: DragEvent): void {\n    const target = event.target as HTMLElement | null;\n    const row = target?.closest('tr');\n    if (!row) {\n      return;\n    }\n\n    const handle = target?.closest(this.dragHandleSelector);\n    const isArmed = row.dataset['dragArmed'] === 'true';\n    if ((!handle || !row.contains(handle)) && !isArmed) {\n      event.preventDefault();\n      return;\n    }\n\n    this.draggedRow = row as HTMLTableRowElement;\n    this.draggedRow.dataset['dragging'] = 'true';\n\n    if (event.dataTransfer) {\n      event.dataTransfer.effectAllowed = 'move';\n      event.dataTransfer.setData('text/plain', '');\n    }\n  }\n\n  private onDragOver(event: DragEvent, tbody: HTMLTableSectionElement): void {\n    if (!this.draggedRow) {\n      return;\n    }\n\n    event.preventDefault();\n    const target = event.target as HTMLElement | null;\n    const targetRow = target?.closest('tr') as HTMLTableRowElement | null;\n\n    if (!targetRow || targetRow === this.draggedRow) {\n      return;\n    }\n\n    const rect = targetRow.getBoundingClientRect();\n    const shouldInsertBefore = event.clientY < rect.top + rect.height / 2;\n    tbody.insertBefore(this.draggedRow, shouldInsertBefore ? targetRow : targetRow.nextSibling);\n  }\n\n  private onDrop(event: DragEvent): void {\n    event.preventDefault();\n  }\n\n  private onDragEnd(): void {\n    const tbody = this.getTbody();\n    if (tbody) {\n      Array.from(tbody.rows).forEach((row) => {\n        row.draggable = false;\n        delete row.dataset['dragArmed'];\n      });\n    }\n\n    if (this.draggedRow) {\n      delete this.draggedRow.dataset['dragging'];\n      this.draggedRow = null;\n    }\n\n    if (!tbody) {\n      return;\n    }\n\n    const order = Array.from(tbody.rows).map((row, index) => row.getAttribute('data-row-id') || String(index));\n    this.rowOrderChange.emit(order);\n  }\n\n  private armDragFromHandle(event: MouseEvent): void {\n    const target = event.target as HTMLElement | null;\n    const handle = target?.closest(this.dragHandleSelector);\n    if (!handle) {\n      return;\n    }\n\n    const row = handle.closest('tr') as HTMLTableRowElement | null;\n    if (!row) {\n      return;\n    }\n\n    row.draggable = true;\n    row.dataset['dragArmed'] = 'true';\n  }\n}\n","<div [ngClass]=\"wrapperClasses\" [attr.data-slot]=\"variant === 'interactive' ? 'table-container' : null\">\n  <table #tableElement [ngClass]=\"tableClasses\" [attr.data-slot]=\"variant === 'interactive' ? 'table' : null\">\n    <ng-content></ng-content>\n  </table>\n</div>\n"]}