@universal-ember/table 3.0.3 → 3.1.0

package/src/plugins/column-resizing/helpers.ts

@@ -15,13 +15,13 @@ import type { Column } from '../../index.ts';
  * be marked as isResizing, because this is a user-scoped question:
  *   "Is the user directly resizing this column?"
  */
-export const isResizing = (column: Column) =>
+export const isResizing = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnResizing).isResizing;
 
 /**
  * Does the column have room to shrink?
  */
-export const canShrink = (column: Column) =>
+export const canShrink = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnResizing).canShrink;
 
 /**
@@ -31,7 +31,7 @@ export const canShrink = (column: Column) =>
  *   - if resizing is enabled for the whole table
  *   - or if we're asking about the first column (resize handles may only be "between" columns)
  */
-export const hasResizeHandle = (column: Column) =>
+export const hasResizeHandle = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnResizing).hasResizeHandle;
 
 /**

package/src/plugins/column-resizing/plugin.ts

@@ -67,6 +67,19 @@ export interface TableOptions {
    * Valid values are 'left' or 'right'
    */
   handlePosition?: string;
+
+  /**
+   * Specify the table layout strategy for column resizing.
+   *
+   * - 'auto': Uses complex redistribution logic where resizing one column
+   *   affects neighboring columns (default, preserves existing behavior)
+   * - 'fixed': Simple per-column resizing suitable for CSS table-layout: fixed
+   *
+   * Valid values are 'auto' or 'fixed'
+   *
+   * default: 'auto'
+   */
+  tableLayout?: string;
 }
 
 interface Signature {
@@ -375,9 +388,42 @@ export class TableMeta {
   }
 
   @action
-  resizeColumn(column: Column, delta: number) {
+  resizeColumn<DataType = unknown>(column: Column<DataType>, delta: number) {
     if (delta === 0) return;
 
+    const tableLayout = this.options?.tableLayout ?? 'auto';
+
+    if (tableLayout === 'fixed') {
+      this.#resizeColumnFixed(column, delta);
+    } else {
+      this.#resizeColumnAuto(column, delta);
+    }
+  }
+
+  /**
+   * Simple column resizing for table-layout: fixed
+   * Only affects the target column and respects minimum width
+   */
+  #resizeColumnFixed<DataType = unknown>(
+    column: Column<DataType>,
+    delta: number,
+  ) {
+    const columnMeta = meta.forColumn(column, ColumnResizing);
+    const newWidth = columnMeta.width + delta;
+
+    if (newWidth >= columnMeta.minWidth) {
+      columnMeta.width = newWidth;
+    }
+  }
+
+  /**
+   * Complex column resizing with redistribution logic
+   * Preserves existing behavior for table-layout: auto
+   */
+  #resizeColumnAuto<DataType = unknown>(
+    column: Column<DataType>,
+    delta: number,
+  ) {
     /**
      * When the delta is negative, we are dragging to the next
      * when positive, we are dragging to the right
@@ -397,7 +443,7 @@ export class TableMeta {
     const isDraggingRight = delta > 0;
     const position = this.options?.handlePosition ?? 'left';
 
-    let growingColumn: Column | null | undefined;
+    let growingColumn: Column<DataType> | null | undefined;
 
     if (position === 'right') {
       growingColumn = isDraggingRight ? columns.next(column) : column;

package/src/plugins/column-visibility/helpers.ts

@@ -6,23 +6,23 @@ import type { Column } from '../../index.ts';
 /**
  * Hide a column
  */
-export const hide = (column: Column) =>
+export const hide = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnVisibility).hide();
 
 /**
  * Show a column
  */
-export const show = (column: Column) =>
+export const show = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnVisibility).show();
 
 /**
  * Ask if a column is presently supposed to be visible
  */
-export const isVisible = (column: Column) =>
+export const isVisible = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnVisibility).isVisible;
 
 /**
  * Ask if a column is presently supposed to be hidden
  */
-export const isHidden = (column: Column) =>
+export const isHidden = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, ColumnVisibility).isHidden;

package/src/plugins/data-sorting/helpers.ts

@@ -6,31 +6,31 @@ import type { Column } from '../../index.ts';
 /**
  * Query a specific column's current sort direction
  */
-export const sortDirection = (column: Column) =>
+export const sortDirection = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, Sorting).sortDirection;
 
 /**
  * Ask if a column is sortable
  */
-export const isSortable = (column: Column) =>
+export const isSortable = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, Sorting).isSortable;
 
 /**
  * Ask if a column is ascending
  */
-export const isAscending = (column: Column) =>
+export const isAscending = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, Sorting).isAscending;
 
 /**
  * Ask if a column is sorted descending
  */
-export const isDescending = (column: Column) =>
+export const isDescending = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, Sorting).isDescending;
 
 /**
  * Ask if a column is not sorted
  */
-export const isUnsorted = (column: Column) =>
+export const isUnsorted = <DataType = unknown>(column: Column<DataType>) =>
   meta.forColumn(column, Sorting).isUnsorted;
 
 /**
@@ -40,17 +40,17 @@ export const isUnsorted = (column: Column) =>
  *   Ascending => None => Descending
  *    ⬑ ---------- <= ---------- ↲
  */
-export const sort = (column: Column) =>
+export const sort = <DataType = unknown>(column: Column<DataType>) =>
   meta.forTable(column.table, Sorting).handleSort(column);
 
 /**
  * Toggle a column between descending and not unsorted states
  */
-export const sortDescending = (column: Column) =>
+export const sortDescending = <DataType = unknown>(column: Column<DataType>) =>
   meta.forTable(column.table, Sorting).toggleDescending(column);
 
 /**
  * Toggle a column between ascending and not unsorted states
  */
-export const sortAscending = (column: Column) =>
+export const sortAscending = <DataType = unknown>(column: Column<DataType>) =>
   meta.forTable(column.table, Sorting).toggleAscending(column);

package/src/plugins/data-sorting/plugin.ts

@@ -157,7 +157,7 @@ export class TableMeta {
   }
 
   @action
-  handleSort(column: Column) {
+  handleSort<DataType = unknown>(column: Column<DataType>) {
     const columnMeta = meta.forColumn(column, Sorting);
 
     if (!columnMeta.sortProperty) {
@@ -184,7 +184,7 @@ export class TableMeta {
   }
 
   @action
-  toggleAscending(column: Column) {
+  toggleAscending<DataType = unknown>(column: Column<DataType>) {
     const columnMeta = meta.forColumn(column, Sorting);
 
     if (!columnMeta.sortProperty) {
@@ -201,7 +201,7 @@ export class TableMeta {
   }
 
   @action
-  toggleDescending(column: Column) {
+  toggleDescending<DataType = unknown>(column: Column<DataType>) {
     const columnMeta = meta.forColumn(column, Sorting);
 
     if (!columnMeta.sortProperty) {

package/dist/_rollupPluginBabelHelpers-BpiaYhlf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"_rollupPluginBabelHelpers-BpiaYhlf.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}