pdm-ui-kit 0.4.2 → 1.0.0

package/esm2020/data-table/data-table.module.mjs

@@ -0,0 +1,29 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { PdmDataTableComponent } from './data-table.component';
+import { PdmDraggableTableComponent } from './draggable-table.component';
+import { PdmTableComponent } from './table.component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [
+    PdmDataTableComponent,
+    PdmDraggableTableComponent,
+    PdmTableComponent,
+];
+export class PdmDataTableModule {
+}
+PdmDataTableModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmDataTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PdmDataTableModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: PdmDataTableModule, declarations: [PdmDataTableComponent,
+        PdmDraggableTableComponent,
+        PdmTableComponent], imports: [CommonModule], exports: [PdmDataTableComponent,
+        PdmDraggableTableComponent,
+        PdmTableComponent] });
+PdmDataTableModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmDataTableModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmDataTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: COMPONENTS,
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS10YWJsZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGF0YS10YWJsZS9kYXRhLXRhYmxlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMvRCxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUN6RSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQzs7QUFFdEQsTUFBTSxVQUFVLEdBQUc7SUFDakIscUJBQXFCO0lBQ3JCLDBCQUEwQjtJQUMxQixpQkFBaUI7Q0FDbEIsQ0FBQztBQU9GLE1BQU0sT0FBTyxrQkFBa0I7OytHQUFsQixrQkFBa0I7Z0hBQWxCLGtCQUFrQixpQkFWN0IscUJBQXFCO1FBQ3JCLDBCQUEwQjtRQUMxQixpQkFBaUIsYUFJUCxZQUFZLGFBTnRCLHFCQUFxQjtRQUNyQiwwQkFBMEI7UUFDMUIsaUJBQWlCO2dIQVFOLGtCQUFrQixZQUpuQixZQUFZOzJGQUlYLGtCQUFrQjtrQkFMOUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLFlBQVksRUFBRSxVQUFVO29CQUN4QixPQUFPLEVBQUUsVUFBVTtpQkFDcEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFBkbURhdGFUYWJsZUNvbXBvbmVudCB9IGZyb20gJy4vZGF0YS10YWJsZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgUGRtRHJhZ2dhYmxlVGFibGVDb21wb25lbnQgfSBmcm9tICcuL2RyYWdnYWJsZS10YWJsZS5jb21wb25lbnQnO1xuaW1wb3J0IHsgUGRtVGFibGVDb21wb25lbnQgfSBmcm9tICcuL3RhYmxlLmNvbXBvbmVudCc7XG5cbmNvbnN0IENPTVBPTkVOVFMgPSBbXG4gIFBkbURhdGFUYWJsZUNvbXBvbmVudCxcbiAgUGRtRHJhZ2dhYmxlVGFibGVDb21wb25lbnQsXG4gIFBkbVRhYmxlQ29tcG9uZW50LFxuXTtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogQ09NUE9ORU5UUyxcbiAgZXhwb3J0czogQ09NUE9ORU5UU1xufSlcbmV4cG9ydCBjbGFzcyBQZG1EYXRhVGFibGVNb2R1bGUge31cbiJdfQ==

package/esm2020/data-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-solid', 'border-border', 'bg-background'];
+        }
+        if (this.variant === 'data') {
+            return ['rounded-md', 'border border-solid', '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/data-table/draggable-table.component.ts","../../../../src/data-table/draggable-table.component.html"],"names":[],"mappings":"AAAA,OAAO,EAEL,uBAAuB,EACvB,SAAS,EAET,YAAY,EACZ,KAAK,EAGL,MAAM,EAGN,SAAS,EACV,MAAM,eAAe,CAAC;;;AAIvB;;;;;;;;;;;;;;;;;;GAkBG;AAMH,MAAM,OAAO,0BAA0B;IA8BrC,YAA6B,QAAmB;QAAnB,aAAQ,GAAR,QAAQ,CAAW;QA7BvC,YAAO,GAAoB,SAAS,CAAC;QACrC,uBAAkB,GAA4B,QAAQ,CAAC;QACvD,cAAS,GAAG,EAAE,CAAC;QACf,cAAS,GAAG,KAAK,CAAC;QAE3B;;WAEG;QACM,gBAAW,GAAG,KAAK,CAAC;QAE7B;;;;WAIG;QACM,uBAAkB,GAAG,yFAAyF,CAAC;QAExH;;;WAGG;QACO,mBAAc,GAAG,IAAI,YAAY,EAAY,CAAC;QAIhD,qBAAgB,GAAsB,EAAE,CAAC;QAEzC,eAAU,GAA+B,IAAI,CAAC;IAEH,CAAC;IAEpD,eAAe;QACb,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,+DAA+D;IAC/D,IAAI,cAAc;QAChB,MAAM,WAAW,GAAG,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;QAC3C,MAAM,eAAe,GAAG,IAAI,CAAC,4BAA4B,EAAE,CAAC;QAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,wBAAwB,EAAE,CAAC;QAEvD,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,kBAAkB,KAAK,QAAQ,EAAE;YAC1D,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;SACzD;QAED,OAAO;YACL,GAAG,WAAW;YACd,GAAG,eAAe;YAClB,GAAG,cAAc;YACjB,IAAI,CAAC,SAAS;SACf,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACpB,CAAC;IAED,IAAI,YAAY;QACd,MAAM,WAAW,GAAG,CAAC,QAAQ,EAAE,gBAAgB,EAAE,SAAS,CAAC,CAAC;QAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;QACrD,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAE1C,OAAO,CAAC,GAAG,WAAW,EAAE,GAAG,cAAc,EAAE,GAAG,WAAW,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7E,CAAC;IAEO,4BAA4B;QAClC,IAAI,IAAI,CAAC,kBAAkB,KAAK,QAAQ,IAAI,IAAI,CAAC,kBAAkB,KAAK,MAAM,IAAI,IAAI,CAAC,kBAAkB,KAAK,UAAU,EAAE;YACxH,OAAO,CAAC,iBAAiB,CAAC,CAAC;SAC5B;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAEO,wBAAwB;QAC9B,IAAI,IAAI,CAAC,OAAO,KAAK,aAAa,EAAE;YAClC,OAAO,CAAC,YAAY,EAAE,qBAAqB,EAAE,eAAe,EAAE,eAAe,CAAC,CAAC;SAChF;QACD,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM,EAAE;YAC3B,OAAO,CAAC,YAAY,EAAE,qBAAqB,EAAE,eAAe,EAAE,eAAe,CAAC,CAAC;SAChF;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAEO,sBAAsB;QAC5B,IAAI,IAAI,CAAC,OAAO,KAAK,MAAM,EAAE;YAC3B,OAAO;gBACL,iBAAiB,EAAE,iBAAiB;gBACpC,uBAAuB,EAAE,4BAA4B;gBACrD,uBAAuB,EAAE,4BAA4B;gBACrD,oCAAoC;gBACpC,aAAa,EAAE,aAAa,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,oBAAoB;gBAC7F,YAAY,EAAE,qBAAqB;aACpC,CAAC;SACH;QAED,IAAI,IAAI,CAAC,OAAO,KAAK,aAAa,EAAE;YAClC,OAAO;gBACL,iBAAiB;gBACjB,kBAAkB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,uBAAuB;gBAChF,uBAAuB,EAAE,4BAA4B;gBACrD,aAAa,EAAE,aAAa,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,oBAAoB;gBAC/G,uBAAuB,EAAE,4BAA4B;gBACrD,gCAAgC,EAAE,gCAAgC;gBAClE,oCAAoC;gBACpC,aAAa,EAAE,aAAa,EAAE,qBAAqB,EAAE,gBAAgB;gBACrE,+BAA+B;aAChC,CAAC;SACH;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IAEO,cAAc;QACpB,IAAI,IAAI,CAAC,kBAAkB,KAAK,QAAQ,EAAE;YACxC,OAAO,CAAC,0BAA0B,EAAE,0BAA0B,EAAE,6BAA6B,EAAE,6BAA6B,CAAC,CAAC;SAC/H;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,MAAM,EAAE;YACtC,OAAO,CAAC,0BAA0B,EAAE,oBAAoB,EAAE,0BAA0B,CAAC,CAAC;SACvF;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,aAAa,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,EAAE;YAChD,IAAI,CAAC,mBAAmB,EAAE,CAAC;SAC5B;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,sBAAsB,EAAE,CAAC;IAChC,CAAC;IAEO,mBAAmB;QACzB,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACrB,OAAO;SACR;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC,KAAK,EAAE;YACV,OAAO;SACR;QAED,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAEnC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CACxB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,KAAiB,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,EAC9F,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,CAAC,KAAgB,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,EACvF,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC,KAAgB,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,EAC5F,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,KAAgB,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAC7E,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC,CAC/D,CAAC;QAEF,uEAAuE;QACvE,IAAI,CAAC,QAAQ,GAAG,IAAI,gBAAgB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACpD,CAAC;IAEO,sBAAsB;QAC5B,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;QAE3B,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC;YAC3B,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC;SAC3B;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;SACrC;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAEO,QAAQ;QACd,OAAO,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IAClE,CAAC;IAEO,gBAAgB,CAAC,KAA8B,EAAE,OAAgB;QACvE,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACnB,IAAI,CAAC,kBAAkB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;YACtC,GAAG,CAAC,SAAS,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,OAAO,EAAE;gBACZ,OAAO,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;gBAC/B,OAAO,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;aACjC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,GAAwB,EAAE,OAAgB;QACnE,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,CAAC,SAAS,EAAE;YACd,OAAO;SACR;QAED,MAAM,kBAAkB,GAAG,SAAS,CAAC,aAAa,CAAC,yBAAyB,CAAC,CAAC;QAC9E,IAAI,CAAC,OAAO,EAAE;YACZ,kBAAkB,EAAE,MAAM,EAAE,CAAC;YAC7B,OAAO;SACR;QAED,MAAM,eAAe,GAAG,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,iEAAiE,CAAC,CAAC;QACrH,IAAI,eAAe,IAAI,kBAAkB,EAAE;YACzC,OAAO;SACR;QAED,0BAA0B;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,QAAQ,CAAsB,CAAC;QAC1E,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,CAAC,CAAC;QAC7D,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,MAAM,EAAE,uBAAuB,EAAE,MAAM,CAAC,CAAC;QACpE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;QACzD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;QAExD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;QAC7C,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAExC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;IACtE,CAAC;IAEO,WAAW,CAAC,KAAgB;QAClC,MAAM,MAAM,GAAG,KAAK,CAAC,MAA4B,CAAC;QAClD,MAAM,GAAG,GAAG,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,GAAG,EAAE;YACR,OAAO;SACR;QAED,MAAM,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACxD,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,KAAK,MAAM,CAAC;QACpD,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE;YAClD,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,OAAO;SACR;QAED,IAAI,CAAC,UAAU,GAAG,GAA0B,CAAC;QAC7C,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC;QAE7C,IAAI,KAAK,CAAC,YAAY,EAAE;YACtB,KAAK,CAAC,YAAY,CAAC,aAAa,GAAG,MAAM,CAAC;YAC1C,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;SAC9C;IACH,CAAC;IAEO,UAAU,CAAC,KAAgB,EAAE,KAA8B;QACjE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE;YACpB,OAAO;SACR;QAED,KAAK,CAAC,cAAc,EAAE,CAAC;QACvB,MAAM,MAAM,GAAG,KAAK,CAAC,MAA4B,CAAC;QAClD,MAAM,SAAS,GAAG,MAAM,EAAE,OAAO,CAAC,IAAI,CAA+B,CAAC;QAEtE,IAAI,CAAC,SAAS,IAAI,SAAS,KAAK,IAAI,CAAC,UAAU,EAAE;YAC/C,OAAO;SACR;QAED,MAAM,IAAI,GAAG,SAAS,CAAC,qBAAqB,EAAE,CAAC;QAC/C,MAAM,kBAAkB,GAAG,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;QACtE,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAC9F,CAAC;IAEO,MAAM,CAAC,KAAgB;QAC7B,KAAK,CAAC,cAAc,EAAE,CAAC;IACzB,CAAC;IAEO,SAAS;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,KAAK,EAAE;YACT,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;gBACrC,GAAG,CAAC,SAAS,GAAG,KAAK,CAAC;gBACtB,OAAO,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;SACJ;QAED,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,OAAO,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;YAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;SACxB;QAED,IAAI,CAAC,KAAK,EAAE;YACV,OAAO;SACR;QAED,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,GAAG,CAAC,YAAY,CAAC,aAAa,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC3G,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAEO,iBAAiB,CAAC,KAAiB;QACzC,MAAM,MAAM,GAAG,KAAK,CAAC,MAA4B,CAAC;QAClD,MAAM,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACxD,IAAI,CAAC,MAAM,EAAE;YACX,OAAO;SACR;QAED,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAA+B,CAAC;QAC/D,IAAI,CAAC,GAAG,EAAE;YACR,OAAO;SACR;QAED,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;QACrB,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,MAAM,CAAC;IACpC,CAAC;;uHAxTU,0BAA0B;2GAA1B,0BAA0B,6aCzCvC,uRAKA;2FDoCa,0BAA0B;kBALtC,SAAS;+BACE,qBAAqB,mBAEd,uBAAuB,CAAC,MAAM;gGAGtC,OAAO;sBAAf,KAAK;gBACG,kBAAkB;sBAA1B,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBAKG,WAAW;sBAAnB,KAAK;gBAOG,kBAAkB;sBAA1B,KAAK;gBAMI,cAAc;sBAAvB,MAAM;gBAEoB,YAAY;sBAAtC,SAAS;uBAAC,cAAc","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.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-solid', 'border-border', 'bg-background'];\n    }\n    if (this.variant === 'data') {\n      return ['rounded-md', 'border border-solid', '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"]}

package/esm2020/data-table/table.component.mjs

@@ -0,0 +1,182 @@
+import { ChangeDetectionStrategy, Component, Input } from "@angular/core";
+import { TABLE_RESPONSIVE, } from "../utils/responsive";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Componente base de tabla con soporte responsive
+ *
+ * SIMPLIFICADO: Ya no incluye drag & drop (usar pdm-draggable-table para eso)
+ *
+ * @example
+ * // Tabla simple con scroll horizontal
+ * <pdm-table variant="default">
+ *   <thead><tr><th>Name</th><th>Email</th></tr></thead>
+ *   <tbody><tr><td>John</td><td>john@example.com</td></tr></tbody>
+ * </pdm-table>
+ *
+ * @example
+ * // Tabla interactiva con wrap en mobile
+ * <pdm-table variant="interactive" responsiveStrategy="wrap">
+ *   ...
+ * </pdm-table>
+ */
+export class PdmTableComponent {
+    constructor() {
+        /**
+         * Variante visual de la tabla
+         * - default: tabla básica sin estilos extra
+         * - data: tabla con bordes y espaciado para data
+         * - interactive: tabla con hover, sticky header y estilos interactivos
+         */
+        this.variant = "default";
+        /**
+         * Estrategia responsive para la tabla
+         * - scroll: scroll horizontal en mobile (default, más simple)
+         * - wrap: permite que el contenido haga wrap
+         * - stack: convierte filas en cards en mobile (requiere data-label en celdas)
+         * - collapse: oculta columnas menos importantes en mobile
+         */
+        this.responsiveStrategy = "scroll";
+        /**
+         * Clases CSS adicionales para el wrapper
+         */
+        this.className = "";
+        /**
+         * Si es true, aplica padding negativo en mobile para scroll edge-to-edge
+         * Útil cuando la tabla está dentro de un container con padding
+         */
+        this.fullBleed = false;
+    }
+    get wrapperClasses() {
+        const baseClasses = ["relative", "w-full"];
+        const strategyClasses = this.getResponsiveStrategyClasses();
+        const variantClasses = this.getVariantWrapperClasses();
+        // Full bleed: scroll edge-to-edge en mobile
+        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() {
+        const strategy = TABLE_RESPONSIVE[this.responsiveStrategy];
+        if (this.responsiveStrategy === "scroll") {
+            return ["overflow-x-auto"];
+        }
+        if (this.responsiveStrategy === "wrap") {
+            return ["overflow-x-auto"];
+        }
+        if (this.responsiveStrategy === "stack") {
+            // Stack requiere lógica en el template, aquí solo el wrapper
+            return [];
+        }
+        if (this.responsiveStrategy === "collapse") {
+            return ["overflow-x-auto"];
+        }
+        return ["overflow-auto"];
+    }
+    getVariantWrapperClasses() {
+        if (this.variant === "interactive") {
+            return ["rounded-xl", "border border-solid", "border-border", "bg-background"];
+        }
+        if (this.variant === "data") {
+            return ["rounded-md", "border border-solid", "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() {
+        // Manejo responsive de whitespace
+        if (this.responsiveStrategy === "scroll") {
+            // En scroll, permitir wrap en mobile, nowrap en desktop
+            return [
+                "[&_td]:whitespace-normal",
+                "[&_th]:whitespace-normal",
+                "sm:[&_td]:whitespace-nowrap",
+                "sm:[&_th]:whitespace-nowrap",
+            ];
+        }
+        if (this.responsiveStrategy === "wrap") {
+            // En wrap, siempre permitir wrap
+            return [
+                "[&_td]:whitespace-normal",
+                "[&_td]:break-words",
+                "[&_th]:whitespace-normal",
+            ];
+        }
+        // Default: nowrap (comportamiento anterior para backward compatibility)
+        return [];
+    }
+}
+PdmTableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: PdmTableComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+PdmTableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: PdmTableComponent, selector: "pdm-table", inputs: { variant: "variant", responsiveStrategy: "responsiveStrategy", className: "className", fullBleed: "fullBleed" }, 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", styles: [":host{display:block}\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: PdmTableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "pdm-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", styles: [":host{display:block}\n"] }]
+        }], propDecorators: { variant: [{
+                type: Input
+            }], responsiveStrategy: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], fullBleed: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table.component.js","sourceRoot":"","sources":["../../../../src/data-table/table.component.ts","../../../../src/data-table/table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectionStrategy, Component, Input } from \"@angular/core\";\nimport {\n\ttype TableResponsiveStrategy,\n\tTABLE_RESPONSIVE,\n} from \"../utils/responsive\";\n\nexport type PdmTableVariant = \"default\" | \"data\" | \"interactive\";\n\n/**\n * Componente base de tabla con soporte responsive\n *\n * SIMPLIFICADO: Ya no incluye drag & drop (usar pdm-draggable-table para eso)\n *\n * @example\n * // Tabla simple con scroll horizontal\n * <pdm-table variant=\"default\">\n *   <thead><tr><th>Name</th><th>Email</th></tr></thead>\n *   <tbody><tr><td>John</td><td>john@example.com</td></tr></tbody>\n * </pdm-table>\n *\n * @example\n * // Tabla interactiva con wrap en mobile\n * <pdm-table variant=\"interactive\" responsiveStrategy=\"wrap\">\n *   ...\n * </pdm-table>\n */\n@Component({\n\tselector: \"pdm-table\",\n\ttemplateUrl: \"./table.component.html\",\n\tstyles: [\":host { display: block; }\"],\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PdmTableComponent {\n\t/**\n\t * Variante visual de la tabla\n\t * - default: tabla básica sin estilos extra\n\t * - data: tabla con bordes y espaciado para data\n\t * - interactive: tabla con hover, sticky header y estilos interactivos\n\t */\n\t@Input() variant: PdmTableVariant = \"default\";\n\n\t/**\n\t * Estrategia responsive para la tabla\n\t * - scroll: scroll horizontal en mobile (default, más simple)\n\t * - wrap: permite que el contenido haga wrap\n\t * - stack: convierte filas en cards en mobile (requiere data-label en celdas)\n\t * - collapse: oculta columnas menos importantes en mobile\n\t */\n\t@Input() responsiveStrategy: TableResponsiveStrategy = \"scroll\";\n\n\t/**\n\t * Clases CSS adicionales para el wrapper\n\t */\n\t@Input() className = \"\";\n\n\t/**\n\t * Si es true, aplica padding negativo en mobile para scroll edge-to-edge\n\t * Útil cuando la tabla está dentro de un container con padding\n\t */\n\t@Input() fullBleed = false;\n\n\tget wrapperClasses(): string[] {\n\t\tconst baseClasses = [\"relative\", \"w-full\"];\n\t\tconst strategyClasses = this.getResponsiveStrategyClasses();\n\t\tconst variantClasses = this.getVariantWrapperClasses();\n\n\t\t// Full bleed: scroll edge-to-edge en mobile\n\t\tif (this.fullBleed && this.responsiveStrategy === \"scroll\") {\n\t\t\tbaseClasses.push(\"-mx-4\", \"px-4\", \"sm:mx-0\", \"sm:px-0\");\n\t\t}\n\n\t\treturn [\n\t\t\t...baseClasses,\n\t\t\t...strategyClasses,\n\t\t\t...variantClasses,\n\t\t\tthis.className,\n\t\t].filter(Boolean);\n\t}\n\n\tget tableClasses(): string[] {\n\t\tconst baseClasses = [\"w-full\", \"caption-bottom\", \"text-sm\"];\n\t\tconst variantClasses = this.getVariantTableClasses();\n\t\tconst cellClasses = this.getCellClasses();\n\n\t\treturn [...baseClasses, ...variantClasses, ...cellClasses].filter(Boolean);\n\t}\n\n\tprivate getResponsiveStrategyClasses(): string[] {\n\t\tconst strategy = TABLE_RESPONSIVE[this.responsiveStrategy];\n\n\t\tif (this.responsiveStrategy === \"scroll\") {\n\t\t\treturn [\"overflow-x-auto\"];\n\t\t}\n\n\t\tif (this.responsiveStrategy === \"wrap\") {\n\t\t\treturn [\"overflow-x-auto\"];\n\t\t}\n\n\t\tif (this.responsiveStrategy === \"stack\") {\n\t\t\t// Stack requiere lógica en el template, aquí solo el wrapper\n\t\t\treturn [];\n\t\t}\n\n\t\tif (this.responsiveStrategy === \"collapse\") {\n\t\t\treturn [\"overflow-x-auto\"];\n\t\t}\n\n\t\treturn [\"overflow-auto\"];\n\t}\n\n\tprivate getVariantWrapperClasses(): string[] {\n\t\tif (this.variant === \"interactive\") {\n\t\t\treturn [\"rounded-xl\", \"border border-solid\", \"border-border\", \"bg-background\"];\n\t\t}\n\n\t\tif (this.variant === \"data\") {\n\t\t\treturn [\"rounded-md\", \"border border-solid\", \"border-border\", \"bg-background\"];\n\t\t}\n\n\t\treturn [];\n\t}\n\n\tprivate getVariantTableClasses(): string[] {\n\t\tif (this.variant === \"data\") {\n\t\t\treturn [\n\t\t\t\t\"border-collapse\",\n\t\t\t\t\"text-foreground\",\n\t\t\t\t\"[&_thead_tr]:border-b\",\n\t\t\t\t\"[&_thead_tr]:border-border\",\n\t\t\t\t\"[&_tbody_tr]:border-b\",\n\t\t\t\t\"[&_tbody_tr]:border-border\",\n\t\t\t\t\"[&_tbody_tr:last-child]:border-b-0\",\n\t\t\t\t\"[&_th]:h-10\",\n\t\t\t\t\"[&_th]:px-2\",\n\t\t\t\t\"[&_th]:text-left\",\n\t\t\t\t\"[&_th]:align-middle\",\n\t\t\t\t\"[&_th]:font-medium\",\n\t\t\t\t\"[&_td]:p-2\",\n\t\t\t\t\"[&_td]:align-middle\",\n\t\t\t];\n\t\t}\n\n\t\tif (this.variant === \"interactive\") {\n\t\t\treturn [\n\t\t\t\t\"text-foreground\",\n\t\t\t\t\"[&_thead]:sticky\",\n\t\t\t\t\"[&_thead]:top-0\",\n\t\t\t\t\"[&_thead]:z-10\",\n\t\t\t\t\"[&_thead]:bg-muted/70\",\n\t\t\t\t\"[&_thead_tr]:border-b\",\n\t\t\t\t\"[&_thead_tr]:border-border\",\n\t\t\t\t\"[&_th]:h-12\",\n\t\t\t\t\"[&_th]:px-4\",\n\t\t\t\t\"[&_th]:text-left\",\n\t\t\t\t\"[&_th]:align-middle\",\n\t\t\t\t\"[&_th]:text-sm\",\n\t\t\t\t\"[&_th]:font-medium\",\n\t\t\t\t\"[&_tbody_tr]:border-b\",\n\t\t\t\t\"[&_tbody_tr]:border-border\",\n\t\t\t\t\"[&_tbody_tr]:transition-colors\",\n\t\t\t\t\"[&_tbody_tr:hover]:bg-muted/50\",\n\t\t\t\t\"[&_tbody_tr:last-child]:border-b-0\",\n\t\t\t\t\"[&_td]:h-14\",\n\t\t\t\t\"[&_td]:px-4\",\n\t\t\t\t\"[&_td]:align-middle\",\n\t\t\t\t\"[&_td]:text-sm\",\n\t\t\t\t\"[&_svg]:text-muted-foreground\",\n\t\t\t];\n\t\t}\n\n\t\treturn [];\n\t}\n\n\tprivate getCellClasses(): string[] {\n\t\t// Manejo responsive de whitespace\n\t\tif (this.responsiveStrategy === \"scroll\") {\n\t\t\t// En scroll, permitir wrap en mobile, nowrap en desktop\n\t\t\treturn [\n\t\t\t\t\"[&_td]:whitespace-normal\",\n\t\t\t\t\"[&_th]:whitespace-normal\",\n\t\t\t\t\"sm:[&_td]:whitespace-nowrap\",\n\t\t\t\t\"sm:[&_th]:whitespace-nowrap\",\n\t\t\t];\n\t\t}\n\n\t\tif (this.responsiveStrategy === \"wrap\") {\n\t\t\t// En wrap, siempre permitir wrap\n\t\t\treturn [\n\t\t\t\t\"[&_td]:whitespace-normal\",\n\t\t\t\t\"[&_td]:break-words\",\n\t\t\t\t\"[&_th]:whitespace-normal\",\n\t\t\t];\n\t\t}\n\n\t\t// Default: nowrap (comportamiento anterior para backward compatibility)\n\t\treturn [];\n\t}\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"]}