@guiexpert/table 1.1.109 → 1.1.113

package/lib/table/column-drag/column-auto-width-context.if.d.ts

@@ -0,0 +1,29 @@
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+
+/**
+ * What {@link ColumnAutoWidthOptionsIf.getWidth} gets to measure a column itself.
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export interface ColumnAutoWidthContextIf {
+    /** Model index of the column. */
+    columnIndex: number;
+    /** The column definition (`undefined` for a table model without column definitions). */
+    columnDef: ColumnDefIf | undefined;
+    /** The property of the column. */
+    property: string | undefined;
+    /** A double click on the resize handle, or a call of {@link TableApi.autoResizeColumn} / {@link TableApi.autoResizeColumns}. */
+    source: "dblclick" | "api";
+    /** First body row drawn now (display index). */
+    firstRenderedRow: number;
+    /** Last body row drawn now (display index, `-1` without rows). */
+    lastRenderedRow: number;
+    /**
+     * Width in px a cell needs for this text: measured with the font of a rendered cell label, plus its padding (the
+     * same measurement as the default).
+     */
+    measureText(text: string): number;
+    /** The default measurement of this column (header, footer, body rows up to {@link ColumnAutoWidthOptionsIf.maxRows}). */
+    getDefaultWidth(): number;
+}

package/lib/table/column-drag/column-auto-width-options.d.ts

@@ -0,0 +1,24 @@
+import { ColumnAutoWidthOptionsIf } from './column-auto-width-options.if.js';
+
+/**
+ * The defaults of {@link ColumnAutoWidthOptionsIf}: double click on, all body rows up to 10 000, no own measurement.
+ *
+ * @example
+ * const options = ColumnAutoWidthOptions.create({ maxRows: 1_000 });
+ * console.log(options.doubleClick, options.maxRows); // true 1000
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export declare class ColumnAutoWidthOptions implements ColumnAutoWidthOptionsIf {
+    doubleClick: boolean;
+    maxRows: number;
+    getWidth?: ColumnAutoWidthOptionsIf["getWidth"];
+    /**
+     * The defaults merged with `options` (`tableOptions.columnAutoWidth`).
+     *
+     * @param {Partial<ColumnAutoWidthOptionsIf>} [options] - own values
+     * @returns {ColumnAutoWidthOptionsIf} complete options
+     */
+    static create(options?: Partial<ColumnAutoWidthOptionsIf>): ColumnAutoWidthOptionsIf;
+}

package/lib/table/column-drag/column-auto-width-options.if.d.ts

@@ -0,0 +1,35 @@
+import { ColumnAutoWidthContextIf } from './column-auto-width-context.if.js';
+
+/**
+ * Fitting a column width to its content: a double click on the resize handle, {@link TableApi.autoResizeColumn} and
+ * {@link TableApi.autoResizeColumns} (`tableOptions.columnAutoWidth`).
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   columnAutoWidth: {
+ *     maxRows: 50_000,
+ *     getWidth: ctx => ctx.property === "message" ? ctx.measureText("x".repeat(80)) : undefined,
+ *   },
+ * };
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export interface ColumnAutoWidthOptionsIf {
+    /**
+     * A double click on the resize handle fits the width of the column to its content. Only where a handle is
+     * (`columnsResizable` and the column is not `resizable: false`). Default `true`.
+     */
+    doubleClick: boolean;
+    /**
+     * Body rows that are measured: up to this number of rows all of them, above only the rows drawn now (the time stays
+     * the same with millions of rows). Header and footer are always measured. Default `10_000`.
+     */
+    maxRows: number;
+    /**
+     * Own measurement: return the width in px, or `undefined` for the default. The result is limited by
+     * `minWidth` / `maxWidth` of the column.
+     */
+    getWidth?: (ctx: ColumnAutoWidthContextIf) => number | undefined;
+}

package/lib/table/column-drag/column-order.d.ts

@@ -0,0 +1,38 @@
+/**
+ * DOM-free order rules of a column drag (prompt 022): columns with `movable: false` are fixed places – the movable
+ * columns fill the other places –, and a column stays in its area (fixed west, center, fixed east).
+ *
+ * Not exported from the package: internals of {@link TableScope} and {@link TableStateService}.
+ */
+/**
+ * The `changeColumnOrder(from, to)` calls that move the column at `from` to the index `to` while every locked column
+ * keeps its index. Without a locked column between `from` and `to` this is the single move `[[from, to]]`.
+ *
+ * @param movable - per column: `false` = locked (fixed place)
+ * @param from - current index of the dragged column
+ * @param to - index the dragged column should get
+ * @returns the moves in order, `[]` for `from === to`, `undefined` if the move is not allowed (a locked source or
+ *          target, an index out of range)
+ */
+export declare function planColumnMove(movable: boolean[], from: number, to: number): [number, number][] | undefined;
+/**
+ * Limits a drop index to the area of the dragged column: a fixed west column stays west, a center column in the
+ * center, a fixed east column east (before 1.1.110 a drag over the border silently changed which column was fixed).
+ *
+ * @param from - index of the dragged column
+ * @param to - index under the mouse
+ * @param count - number of columns
+ * @param fixedLeft - `fixedLeftColumnCount`
+ * @param fixedRight - `fixedRightColumnCount`
+ * @returns `to` within the area of `from`
+ */
+export declare function clampToColumnArea(from: number, to: number, count: number, fixedLeft: number, fixedRight: number): number;
+/**
+ * A column order to apply (e.g. from a stored state) with the locked columns at their current index.
+ *
+ * @param target - the wanted order (properties)
+ * @param current - the order now (properties)
+ * @param locked - properties of the locked columns (`movable: false`)
+ * @returns the order to apply
+ */
+export declare function orderKeepingLocked(target: string[], current: string[], locked: Set<string>): string[];

package/lib/table/column-drag/column-width-measurer.d.ts

@@ -0,0 +1,26 @@
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+
+/**
+ * Measures the width a cell needs for its text (prompt 022, before part of `TableScope.calcAutoColumnWidths`).
+ *
+ * The text is measured with the font and padding of a rendered cell label (canvas `measureText`). Without a canvas
+ * (e.g. in a test environment without one) it falls back to 8 px per character.
+ *
+ * Not exported from the package: an internal of {@link TableScope}.
+ */
+export declare class ColumnWidthMeasurer {
+    /** Texts (per column) whose character length is close to the longest – only they are measured. */
+    static readonly maxCandidates = 30;
+    private readonly ctx;
+    private readonly padding;
+    constructor(hostElement: HTMLElement);
+    /** Width in px of a cell with this text: text width + cell padding + 2 px (rounded up). */
+    measureText(text: string): number;
+    /** The widest of the texts (at least 50 px, like the column widths before 1.1.110). */
+    measureWidest(texts: Set<string>): number;
+}
+/**
+ * Collects per column the texts with (almost) the greatest character length of the rows `fromRow … toRow`.
+ * One pass over the rows and the given columns; `candidates[k]` / `maxLength[k]` belong to `columns[k]`.
+ */
+export declare function collectColumnTextCandidates(model: AreaModelIf | undefined, fromRow: number, toRow: number, columns: number[], candidates: Set<string>[], maxLength: number[]): void;

package/lib/table/data/common/event/ge-column-move-event.d.ts

@@ -0,0 +1,56 @@
+import { ColumnDefIf } from '../../tablemodel/column/column-def.if.js';
+import { GeColumnDragEventType } from './ge-column-resize-event.js';
+
+/**
+ * The user moves a column by dragging its header ({@link EventListenerIf.onColumnMoveStart},
+ * {@link EventListenerIf.onColumnMoveEnd}).
+ *
+ * One start and one end per drag – no event for the steps in between (the table moves the column while the mouse
+ * moves). Only user actions report it, not {@link TableApi.applyState} or `tableModel.changeColumnOrder()`. The end
+ * comes after the table applied the order: in the handler `tableApi.getTableModel().getColumnDefs()` and
+ * {@link TableApi.getState} already have it.
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onColumnMoveEnd = (evt: GeColumnMoveEvent) => {
+ *   if (evt.moved) {
+ *     localStorage.setItem("column-order", JSON.stringify(evt.columnOrder));
+ *   }
+ * };
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export declare class GeColumnMoveEvent {
+    /** Phase: `"start"`, `"end"` or `"cancel"` (Escape: the old order is back). */
+    readonly type: GeColumnDragEventType;
+    /** Model index of the column when the drag started. */
+    readonly fromIndex: number;
+    /** Model index of the column now (`"start"` and `"cancel"`: `fromIndex`; `"end"`: also when it did not change). */
+    readonly toIndex: number;
+    /** The column definition of the dragged column. */
+    readonly columnDef: ColumnDefIf | undefined;
+    /** The property of the dragged column (`columnDef.property`). */
+    readonly property: string | undefined;
+    /** The properties of all columns in the order now (after the move for `"end"`). */
+    readonly columnOrder: string[];
+    /** The browser event behind it (mouse up; `undefined` for {@link TableApi.cancelColumnDrag}). */
+    readonly originalEvent?: Event | undefined;
+    constructor(
+    /** Phase: `"start"`, `"end"` or `"cancel"` (Escape: the old order is back). */
+    type: GeColumnDragEventType, 
+    /** Model index of the column when the drag started. */
+    fromIndex: number, 
+    /** Model index of the column now (`"start"` and `"cancel"`: `fromIndex`; `"end"`: also when it did not change). */
+    toIndex: number, 
+    /** The column definition of the dragged column. */
+    columnDef: ColumnDefIf | undefined, 
+    /** The property of the dragged column (`columnDef.property`). */
+    property: string | undefined, 
+    /** The properties of all columns in the order now (after the move for `"end"`). */
+    columnOrder: string[], 
+    /** The browser event behind it (mouse up; `undefined` for {@link TableApi.cancelColumnDrag}). */
+    originalEvent?: Event | undefined);
+    /** true if the column has another index now (`toIndex !== fromIndex`). */
+    get moved(): boolean;
+}

package/lib/table/data/common/event/ge-column-resize-event.d.ts

@@ -0,0 +1,72 @@
+import { ColumnDefIf } from '../../tablemodel/column/column-def.if.js';
+
+/**
+ * Phase of a column drag (resize or move): `"start"` (the mouse moved past the drag threshold of 4 px, or a double
+ * click on the resize handle), `"end"` (released – also outside of the table) or `"cancel"` (Escape,
+ * {@link TableApi.cancelColumnDrag}: the old width resp. order is back).
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export type GeColumnDragEventType = "start" | "end" | "cancel";
+/**
+ * What changed the width: dragging the resize handle (`"mouse"`) or a double click on it (`"dblclick"`, fits the width
+ * to the content).
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export type GeColumnResizeSource = "mouse" | "dblclick";
+/**
+ * The user resizes a column ({@link EventListenerIf.onColumnResizeStart}, {@link EventListenerIf.onColumnResizeEnd}).
+ *
+ * Only user actions report it – not {@link TableApi.setColumnWidth}, {@link TableApi.applyState},
+ * {@link TableApi.autoResizeColumns} or {@link TableApi.autoResizeColumn}. The end comes once per start, after the
+ * table applied the width: in the handler {@link TableApi.getState} and the table model already have it.
+ *
+ * @example
+ * const listener = new EventAdapter();
+ * listener.onColumnResizeEnd = (evt: GeColumnResizeEvent) => {
+ *   if (evt.type === "end" && evt.property) {
+ *     localStorage.setItem(`width-${evt.property}`, String(evt.newWidth));
+ *   }
+ * };
+ *
+ * @category Column drag
+ * @since 1.1.110
+ */
+export declare class GeColumnResizeEvent {
+    /** Phase: `"start"`, `"end"` or `"cancel"`. */
+    readonly type: GeColumnDragEventType;
+    /** Dragging the handle or a double click on it. */
+    readonly source: GeColumnResizeSource;
+    /** Model index of the column (over west, center and east). */
+    readonly columnIndex: number;
+    /** The column definition – `undefined` for a table model without column definitions. */
+    readonly columnDef: ColumnDefIf | undefined;
+    /** The property of the column (`columnDef.property`) – use it to store the width, indices change. */
+    readonly property: string | undefined;
+    /** Width in px when the drag started. */
+    readonly oldWidth: number;
+    /** Width in px now: `"start"` = `oldWidth`, `"end"` = the new width, `"cancel"` = `oldWidth` again. */
+    readonly newWidth: number;
+    /** The browser event behind it (mouse up, double click; `undefined` for {@link TableApi.cancelColumnDrag}). */
+    readonly originalEvent?: Event | undefined;
+    constructor(
+    /** Phase: `"start"`, `"end"` or `"cancel"`. */
+    type: GeColumnDragEventType, 
+    /** Dragging the handle or a double click on it. */
+    source: GeColumnResizeSource, 
+    /** Model index of the column (over west, center and east). */
+    columnIndex: number, 
+    /** The column definition – `undefined` for a table model without column definitions. */
+    columnDef: ColumnDefIf | undefined, 
+    /** The property of the column (`columnDef.property`) – use it to store the width, indices change. */
+    property: string | undefined, 
+    /** Width in px when the drag started. */
+    oldWidth: number, 
+    /** Width in px now: `"start"` = `oldWidth`, `"end"` = the new width, `"cancel"` = `oldWidth` again. */
+    newWidth: number, 
+    /** The browser event behind it (mouse up, double click; `undefined` for {@link TableApi.cancelColumnDrag}). */
+    originalEvent?: Event | undefined);
+}

package/lib/table/data/common/row-number-column-def.d.ts

@@ -48,6 +48,10 @@ export declare class RowNumberColumnDef implements ColumnDefIf {
     rendererMap: AreaObjectMapType<CellRendererIf>;
     classes: AreaObjectMapType<string[]>;
     isVisible: BooleanFunction;
+    /** No resize handle: the width follows the largest number (since 1.1.110 a flag, before a special case). */
+    resizable: boolean;
+    /** Stays in front: can't be dragged, no column is dropped in front of it (since 1.1.110 a flag). */
+    movable: boolean;
     /** The options (defaults from {@link RowNumberOptions}). */
     readonly options: RowNumberOptionsIf;
     /**

package/lib/table/data/options/table-options.d.ts

@@ -15,6 +15,7 @@ import { HeaderGroupOptions } from './header-group-options.js';
 import { AriaTextsIf } from '../../aria/aria-texts.if.js';
 import { OverlayOptionsIf } from './overlay-options.if.js';
 import { RowDragOptionsIf } from '../../row-drag/row-drag-options.if.js';
+import { ColumnAutoWidthOptionsIf } from '../../column-drag/column-auto-width-options.if.js';
 import { FillHandleOptionsIf } from '../../fill/fill-handle-options.if.js';
 import { EditingOptionsIf } from '../../sheet-editing/editing-options.if.js';
 import { ClipboardOptionsIf } from '../../clipboard/clipboard-options.if.js';
@@ -104,6 +105,8 @@ export declare class TableOptions implements TableOptionsIf {
     /** Texts and behaviour of the "Loading…" / "No rows" overlays; missing fields use {@link OverlayOptions}. @since 1.1.92 */
     overlayOptions?: Partial<OverlayOptionsIf>;
     rowDragOptions?: Partial<RowDragOptionsIf>;
+    /** Fitting a column width to its content (double click on the resize handle …). @since 1.1.110 */
+    columnAutoWidth?: Partial<ColumnAutoWidthOptionsIf>;
     fillHandle?: boolean | Partial<FillHandleOptionsIf>;
     masterDetail?: Partial<MasterDetailOptionsIf>;
     batchEdit?: boolean | Partial<BatchEditOptionsIf>;

package/lib/table/data/options/table-options.if.d.ts

@@ -23,6 +23,7 @@ import { AriaTextsIf } from '../../aria/aria-texts.if.js';
 import { TableStateIf } from '../../state/table-state.if.js';
 import { OverlayOptionsIf } from './overlay-options.if.js';
 import { TableDirection } from '../../rtl/table-direction.type.js';
+import { ColumnAutoWidthOptionsIf } from '../../column-drag/column-auto-width-options.if.js';
 
 /**
  * Represents the options for configuring a table.
@@ -166,13 +167,17 @@ export interface TableOptionsIf {
      */
     hoverColumnVisible: boolean;
     /**
-     * Represents whether the columns are resizable.
+     * The user can change column widths by dragging the handle at the end of a header cell (and fit a width to the
+     * content by a double click on it, {@link columnAutoWidth}). A single column is locked with
+     * `ColumnDef.resizable: false`. Events: {@link EventListenerIf.onColumnResizeStart} / `onColumnResizeEnd`.
      *
      * @type {boolean}
      */
     columnsResizable: boolean;
     /**
-     * Flag indicating whether the columns are draggable.
+     * The user can move columns by dragging a header cell. A single column is locked with `ColumnDef.movable: false`;
+     * a column stays in its area (fixed west, center, fixed east – since 1.1.110). Events:
+     * {@link EventListenerIf.onColumnMoveStart} / `onColumnMoveEnd`.
      *
      * @type {boolean}
      */
@@ -352,6 +357,20 @@ export interface TableOptionsIf {
      * @see [Live demo: row drag](https://gui.expert/showcase/rowdrag/run/) · Training: [Dragging rows into order](https://gui.expert/training/events-and-context-menu/#row-drag)
      */
     rowDragOptions?: Partial<RowDragOptionsIf>;
+    /**
+     * Fitting a column width to its content: double click on the resize handle (on by default), the number of body
+     * rows that are measured, an own measurement (see {@link ColumnAutoWidthOptionsIf}). Also used by
+     * {@link TableApi.autoResizeColumn} and {@link TableApi.autoResizeColumns}.
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = {
+     *   ...new TableOptions(),
+     *   columnAutoWidth: { getWidth: ctx => ctx.property === "id" ? 80 : undefined },
+     * };
+     *
+     * @since 1.1.110
+     */
+    columnAutoWidth?: Partial<ColumnAutoWidthOptionsIf>;
     /**
      * The fill handle: a small square at the bottom right corner of the selected range. Dragging it fills the
      * neighbouring cells (copy, or a series: 1, 2, 3 …, dates, `Item 1` → `Item 2`); ⌥/Alt switches between series and

package/lib/table/data/tablemodel/column/column-def.d.ts

@@ -71,6 +71,10 @@ export declare class ColumnDef implements ColumnDefIf {
     emptyValue?: unknown;
     /** `false`: no cell formulas in this column, see {@link ColumnDefIf.cellFormulas} (since 1.1.99). */
     cellFormulas?: boolean;
+    /** `false`: no resize handle, no auto width, see {@link ColumnDefIf.resizable} (since 1.1.110). */
+    resizable?: boolean;
+    /** `false`: can't be moved by dragging, see {@link ColumnDefIf.movable} (since 1.1.110). */
+    movable?: boolean;
     /** Lower limit for % widths and for resizing with the mouse, see {@link ColumnDefIf.minWidth}. Default `0px`. */
     minWidth: SizeIf;
     /** Upper limit for % widths and for resizing with the mouse, see {@link ColumnDefIf.maxWidth}. Default `100000px`. */
@@ -154,5 +158,9 @@ export declare class ColumnDef implements ColumnDefIf {
         emptyValue?: unknown;
         /** `false`: `"=…"` stays text in this column of a table with cell formulas (since 1.1.99). */
         cellFormulas?: boolean;
+        /** `false`: the user can't resize the column (since 1.1.110). */
+        resizable?: boolean;
+        /** `false`: the user can't move the column (since 1.1.110). */
+        movable?: boolean;
     }): ColumnDefIf;
 }

package/lib/table/data/tablemodel/column/column-def.if.d.ts

@@ -228,6 +228,28 @@ export interface ColumnDefIf {
      * @since 1.1.99
      */
     cellFormulas?: boolean;
+    /**
+     * `false`: the user can't change the width of this column – no resize handle, no double click, and
+     * {@link TableApi.autoResizeColumns} / {@link TableApi.autoResizeColumn} leave it out. `setColumnWidth` and
+     * `applyState` still set it. Default `true` (works only with `tableOptions.columnsResizable`).
+     *
+     * @example
+     * ColumnDef.create({ property: "line", headerLabel: "#", width: px50, resizable: false, movable: false })
+     *
+     * @since 1.1.110
+     */
+    resizable?: boolean;
+    /**
+     * `false`: the user can't move this column – its header is not draggable, and no other column pushes it away (it
+     * keeps its index; `applyState` with another order leaves it in place, too). Default `true` (works only with
+     * `tableOptions.columnsDraggable`). A {@link RowNumberColumnDef} has `resizable` and `movable` `false`.
+     *
+     * @example
+     * ColumnDef.create({ property: "id", headerLabel: "ID", movable: false })
+     *
+     * @since 1.1.110
+     */
+    movable?: boolean;
 }
 /**
  * {@link ColumnDefIf.validate}: a message for an invalid value, `undefined` (or `null`, `""`) for a valid one.

package/lib/table/event-adapter.d.ts

@@ -10,6 +10,8 @@ import { FocusModelIf } from './focus/focus-model.if.js';
 import { GeStateChangeEvent } from './data/common/event/ge-state-change-event.js';
 import { GeBatchEditEvent } from './data/common/event/ge-batch-edit-event.js';
 import { GeRowDragEvent } from './data/common/event/ge-row-drag-event.js';
+import { GeColumnResizeEvent } from './data/common/event/ge-column-resize-event.js';
+import { GeColumnMoveEvent } from './data/common/event/ge-column-move-event.js';
 
 /**
  * Empty implementation of {@link EventListenerIf} – extend it and override only the events you need.
@@ -49,4 +51,12 @@ export declare class EventAdapter implements EventListenerIf {
     onEditingChanged(_evt: GeEditEvent): void;
     /** @since 1.1.99 */
     onUndoStackChanged(_evt: GeUndoEvent): void;
+    /** @since 1.1.110 */
+    onColumnResizeStart(_evt: GeColumnResizeEvent): void;
+    /** @since 1.1.110 */
+    onColumnResizeEnd(_evt: GeColumnResizeEvent): void;
+    /** @since 1.1.110 */
+    onColumnMoveStart(_evt: GeColumnMoveEvent): void;
+    /** @since 1.1.110 */
+    onColumnMoveEnd(_evt: GeColumnMoveEvent): void;
 }

package/lib/table/event-listener.if.d.ts

@@ -1,6 +1,8 @@
 import { GeEditEvent } from './data/common/event/ge-edit-event.js';
 import { GeUndoEvent } from './data/common/event/ge-undo-event.js';
 import { GeDetailEvent } from './data/common/event/ge-detail-event.js';
+import { GeColumnResizeEvent } from './data/common/event/ge-column-resize-event.js';
+import { GeColumnMoveEvent } from './data/common/event/ge-column-move-event.js';
 import { GeMouseEvent } from './data/common/event/ge-mouse-event.js';
 import { GeModelChangeEvent } from './data/common/event/ge-model-change-event.js';
 import { GeScrollEvent } from './data/common/event/ge-scroll-event.js';
@@ -118,4 +120,32 @@ export interface EventListenerIf extends EventFocusChangedListenerIf, EventSelec
      * @since 1.1.99
      */
     onUndoStackChanged?(evt: GeUndoEvent): void;
+    /**
+     * Optional: the user started to resize a column (the mouse moved 4 px with the resize handle pressed, or a double
+     * click on it). Not reported for API calls. See {@link GeColumnResizeEvent}.
+     *
+     * @since 1.1.110
+     */
+    onColumnResizeStart?(evt: GeColumnResizeEvent): void;
+    /**
+     * Optional: a column resize ended – `evt.type` `"end"` (also released outside the table) or `"cancel"` (Escape: the
+     * old width is back). Once per start, after the table applied the width: save the column layout here.
+     *
+     * @since 1.1.110
+     */
+    onColumnResizeEnd?(evt: GeColumnResizeEvent): void;
+    /**
+     * Optional: the user started to move a column (dragged its header 4 px). Not reported for API calls. See
+     * {@link GeColumnMoveEvent}.
+     *
+     * @since 1.1.110
+     */
+    onColumnMoveStart?(evt: GeColumnMoveEvent): void;
+    /**
+     * Optional: a column move ended – `evt.type` `"end"` (`evt.moved` = another index) or `"cancel"` (Escape: the old
+     * order is back). Once per start, no event for the steps in between, after the table applied the order.
+     *
+     * @since 1.1.110
+     */
+    onColumnMoveEnd?(evt: GeColumnMoveEvent): void;
 }

package/lib/table/render-scope.d.ts

@@ -658,8 +658,16 @@ export declare class RenderScope extends EleScope {
      * @since 1.1.93
      */
     getFirstDataColumnIndex(): number;
-    /** false for a row number column: it has no resize handle (its width follows the numbers). */
+    /**
+     * false for `ColumnDef.resizable: false` (e.g. a row number column – its width follows the numbers): no resize handle,
+     * no double click, no auto width (since 1.1.110 a flag, before a special case of the row numbers).
+     */
     protected isColumnResizable(columnIndex: number): boolean;
+    /**
+     * false for `ColumnDef.movable: false` (e.g. a row number column): the header can't be dragged, and no other column
+     * is dropped onto its place (since 1.1.110).
+     */
+    protected isColumnMovable(columnIndex: number): boolean;
     /**
      * The last measured text of the row number column and its width (measured again only when the text changes).
      * `approximate`: measured with the font of the host before a number cell existed – measured again with the font of

package/lib/table/table-api.d.ts

@@ -977,14 +977,63 @@ export declare class TableApi {
      */
     getSelectionAggregates(): SelectionAggregatesIf;
     /**
-     * Automatically resizes all columns to fit their content.
+     * Automatically resizes all columns to fit their content (header, footer and body rows – all up to
+     * {@link ColumnAutoWidthOptionsIf.maxRows}, 10 000, above only the rows drawn now). Leaves out row number columns and
+     * columns with `resizable: false`; uses {@link ColumnAutoWidthOptionsIf.getWidth} and `minWidth` / `maxWidth`.
+     * Reports no column events.
      *
      * @param {boolean} recalcWrappers - Determines whether to recalculate wrapper dimensions after resizing columns.
      *                                   Default value is true.
      *
+     * @example
+     * tableApi.autoResizeColumns();
+     *
      * @return {void} - This method doesn't return anything.
      */
     autoResizeColumns(recalcWrappers?: boolean): void;
+    /**
+     * Fits the width of **one** column to its content – what a double click on its resize handle does, but without
+     * events. Measures header, footer and body rows (all up to {@link ColumnAutoWidthOptionsIf.maxRows}, 10 000, above
+     * only the rows drawn now – the time does not grow with millions of rows), or asks
+     * {@link ColumnAutoWidthOptionsIf.getWidth}; limited by `minWidth` / `maxWidth`.
+     *
+     * @param {number | string | ColumnDefIf} column - column index, property or column definition
+     * @returns {number | undefined} the width set in px; `undefined` for an unknown column, a row number column or a
+     *          column with `resizable: false`
+     *
+     * @example
+     * const width = tableApi.autoResizeColumn("message");
+     * console.log(`message is ${width} px wide now`);
+     *
+     * @since 1.1.110
+     * @see Training: [Remember the state](https://gui.expert/training/persist-state/#column-events)
+     */
+    autoResizeColumn(column: number | string | ColumnDefIf): number | undefined;
+    /**
+     * True while the user resizes or moves a column (between `onColumnResizeStart` / `onColumnMoveStart` and the end).
+     * Renders through the API (repaint, live data) are fine meanwhile; do not change column widths or the column order
+     * yourself then.
+     *
+     * @returns {boolean} true during a column drag
+     *
+     * @example
+     * if (!tableApi.isColumnDragging()) {
+     *   tableApi.applyState(savedLayout, ["columns"]);
+     * }
+     *
+     * @since 1.1.110
+     */
+    isColumnDragging(): boolean;
+    /**
+     * Cancels a running column resize or move like Escape: the old width resp. order is back, `onColumnResizeEnd` /
+     * `onColumnMoveEnd` get the type `"cancel"`. Without a running drag nothing happens.
+     *
+     * @example
+     * tableApi.cancelColumnDrag();   // e.g. another layout was loaded
+     *
+     * @since 1.1.110
+     */
+    cancelColumnDrag(): void;
     /**
      * Recalculates the dimensions of all wrapper elements in the table.
      *