@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/pivot/pivot-table-model.d.ts

@@ -0,0 +1,86 @@
+import { TableModel } from '../data/tablemodel/table-model.js';
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { DefaultRowHeightsIf } from '../data/options/default-row-heights.if.js';
+import { GetT } from '../data/common/get-t.js';
+import { SelectionModelIf } from '../selection/selection-model.if.js';
+import { AreaModelCellGroups } from '../data/tablemodel/areamodel/area-model-cell-groups.js';
+import { AreaModelPivot } from '../data/tablemodel/areamodel/area-model-pivot.js';
+import { AreaModelPivotFooter } from '../data/tablemodel/areamodel/area-model-pivot-footer.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { PivotConfigIf } from './pivot-config.if.js';
+
+/**
+ * The table model of a pivot table – a {@link TableModel} (all wrappers take it) whose columns follow the pivot: a
+ * group column, one column per column key × value, subtotal and total columns, a grouped header and a total row.
+ * Created by {@link PivotFactory.createTableModel}.
+ *
+ * Pivot again at runtime – other fields, values or rows – with {@link TableApi.setPivotConfig}: the same model and the
+ * same table get new columns (no new model, so no rebuild in the framework wrappers).
+ *
+ * @example
+ * const tableModel = PivotFactory.createTableModel<Sale>({
+ *   rows: sales, rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"]
+ * });
+ * tableModel.getPivotBody().getResult().getValue();   // 450
+ * tableModel.getPivotConfig().columnFields;           // ["monat"]
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotTableModel<T = any> extends TableModel {
+    private readonly leadingColumnDefs;
+    private readonly valueWidth?;
+    /** Marker for {@link isPivotTableModel} (works across copies of the core). */
+    readonly kind = "PivotTableModel";
+    private pivotFixedRightColumnCount;
+    /**
+     * Use {@link PivotFactory.createTableModel}.
+     *
+     * @param {AreaModelCellGroups} header - the grouped header
+     * @param {AreaModelPivot<T>} body - the pivot body
+     * @param {AreaModelPivotFooter<T>} footer - the total row
+     * @param {ColumnDefIf[]} leadingColumnDefs - the columns in front of the values (row numbers, group column)
+     * @param {ColumnDefIf[]} columnDefs - all columns (leading columns, value columns, total columns)
+     * @param {number} fixedRightColumnCount - the fixed total columns on the right
+     * @param {number} fixedLeftColumnCount - fixed columns on the left (the leading columns)
+     * @param {DefaultRowHeightsIf} defaultRowHeights - row heights
+     * @param {GetT<SelectionModelIf>} getSelectionModel - selection model factory
+     * @param {SizeIf} [valueWidth] - the width of new value columns
+     */
+    constructor(header: AreaModelCellGroups, body: AreaModelPivot<T>, footer: AreaModelPivotFooter<T>, leadingColumnDefs: ColumnDefIf[], columnDefs: ColumnDefIf[], fixedRightColumnCount: number, fixedLeftColumnCount: number, defaultRowHeights: DefaultRowHeightsIf, getSelectionModel: GetT<SelectionModelIf>, valueWidth?: SizeIf | undefined);
+    getFixedRightColumnCount(): number;
+    /**
+     * The body: cells, row groups, drill-down ({@link AreaModelPivot.getCellSourceRows}) and the {@link PivotResult}.
+     *
+     * @returns {AreaModelPivot<T>} the body model
+     *
+     * @example
+     * const pivotBody = pivotModel.getPivotBody();
+     * pivotBody.getResult().columnLeaves.map(c => c.label);   // ["Feb", "Jan"]
+     */
+    getPivotBody(): AreaModelPivot<T>;
+    /**
+     * The current configuration.
+     *
+     * @returns {PivotConfigIf<T>} a copy
+     *
+     * @example
+     * pivotModel.getPivotConfig().rowFields;   // ["region"]
+     */
+    getPivotConfig(): PivotConfigIf<T>;
+    /**
+     * Pivots again with a changed configuration and/or new rows: new keys, columns, header and totals in this model.
+     * Prefer {@link TableApi.setPivotConfig} – it also lays the table out again; after this method alone the table
+     * must be laid out by you.
+     *
+     * @param {Partial<PivotConfigIf<T>>} changes - the changed parts, e.g. `{ columnFields: ["jahr"] }`
+     * @param {T[]} [rows] - new source rows (default: the current ones)
+     *
+     * @example
+     * pivotModel.setPivotConfig({ values: [{ value: "umsatz", aggregator: "avg" }] });
+     */
+    setPivotConfig(changes: Partial<PivotConfigIf<T>>, rows?: T[]): void;
+    /** Columns and header for the current pivot of the body. */
+    private relayout;
+}

package/lib/table/pivot/pivot-value.type.d.ts

@@ -0,0 +1,80 @@
+import { ValueAccessor } from '../aggregation/value-accessor.type.js';
+import { AggregatorRef } from '../aggregation/aggregator-name.type.js';
+import { AggregatorIf } from '../aggregation/aggregator.if.js';
+import { ShowValuesAsConfig, ShowValuesAsIf } from '../calc/show-values-as.type.js';
+
+/**
+ * One value of a pivot table in full form: where the value of a row comes from, how it is aggregated, and how its
+ * columns are named. The short form is just the {@link ValueAccessor} (`"umsatz"` = the sum of umsatz).
+ *
+ * @example
+ * const revenue: PivotValueIf<Order> = { value: "total", label: "Revenue" };                  // sum
+ * const orders: PivotValueIf<Order> = { value: "id", aggregator: "count", label: "Orders" };
+ * const avgPrice: PivotValueIf<Order> = {
+ *   value: o => o.total / o.quantity, aggregator: "avg", label: "Avg. price",
+ *   format: v => v === undefined ? "" : `${(v as number).toFixed(2)} €`
+ * };
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotValueIf<T = any> {
+    /** The value of a row: a property path (`"umsatz"`, `"order.total"`) or a function. */
+    value: ValueAccessor<T>;
+    /** A built-in aggregator by name (`"sum"`, `"avg"`, `"count"` …) or an own {@link AggregatorIf}. Default `"sum"`. */
+    aggregator?: AggregatorRef;
+    /**
+     * The id of the value – part of the column properties and the name in {@link PivotResult.getValue}.
+     * Default: `"<aggregator>(<path>)"`, e.g. `"sum(umsatz)"`; for a function `"<aggregator>(value<N>)"`.
+     */
+    name?: string;
+    /** The header of its columns (with several values). Default: the name. Text only – never HTML. */
+    label?: string;
+    /** The text of a result in a cell. Default: numbers with at most two decimals (`"1,234.5"`). Excel gets the raw value. */
+    format?: (result: unknown) => string;
+    /**
+     * „Show values as“ (since 1.1.95): `"percentOfRowTotal"` (each pivot row = 100 %), `"percentOfColumnTotal"`,
+     * `"percentOfGrandTotal"` or `"percentOfParentTotal"` (share of the parent row group). The cells then hold the
+     * fraction (Excel: number with percent format), the text is a percentage; `format` is not used. Other modes of
+     * {@link ShowValuesAs} don't apply to a pivot (the value is shown).
+     *
+     * @example
+     * values: [{ value: "umsatz", showValuesAs: "percentOfRowTotal" }]
+     */
+    showValuesAs?: ShowValuesAsConfig;
+}
+/**
+ * A value of a pivot table: a property path or function (summed) or the full form {@link PivotValueIf}.
+ *
+ * @example
+ * const values: PivotValue<Sale>[] = ["umsatz", { value: "umsatz", aggregator: "count", label: "Count" }];
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export type PivotValue<T = any> = ValueAccessor<T> | PivotValueIf<T>;
+/**
+ * A value of a pivot table as the table uses it: name, label, aggregator and format resolved
+ * ({@link PivotResult.values}, {@link PivotColumnInfoIf.value}).
+ *
+ * @example
+ * const pivotBody = pivotModel.getPivotBody();
+ * pivotBody.getResult().values.map(v => v.name);   // ["sum(umsatz)"]
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotValueInfoIf {
+    /** The id ({@link PivotValueIf.name}). */
+    readonly name: string;
+    /** The header label. */
+    readonly label: string;
+    /** The aggregator. */
+    readonly aggregator: AggregatorIf;
+    /** The format of a result, if one was given. */
+    readonly format?: (result: unknown) => string;
+    /** „Show values as“, if one was given (since 1.1.95). */
+    readonly showValuesAs?: ShowValuesAsIf;
+}

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

@@ -1,3 +1,6 @@
+import { RowDragService } from './row-drag/row-drag-service.js';
+import { BatchEditService } from './batch-edit/batch-edit-service.js';
+import { FillHandleService } from './fill/fill-handle-service.js';
 import { TableOverlayChange } from './overlay/table-overlay.js';
 import { EleScope } from './ele-scope.js';
 import { TableModelIf } from './data/tablemodel/table-model.if.js';
@@ -8,6 +11,7 @@ import { RendererCleanupFnType } from './renderer/renderer-cleanup-fn.type.js';
 import { AreaIdent } from './data/tablemodel/area-ident.type.js';
 import { SideIdent } from './data/side-ident.type.js';
 import { DivScope } from './data/div-scope.type.js';
+import { DerivedValuesChangeIf } from './data/tablemodel/areamodel/derived-values-change.if.js';
 import { AreaModelIf } from './data/tablemodel/areamodel/area-model.if.js';
 import { ArgsAdjustColumnsToRowParentParams } from './data/common/args-adjust-columns-to-row-parent-params.js';
 import { ArgsRenderCellDiv } from './data/common/args-render-cell-div.js';
@@ -84,7 +88,80 @@ export declare class RenderScope extends EleScope {
      * first body row, see `TableScope`. `undefined`: the focus is in the body ({@link FocusModelIf}).
      */
     protected headerFocus?: [number, number];
+    /**
+     * Row drag of this table (drag handles, pointer and keyboard drag) – created by {@link TableScope}.
+     * @since 1.1.95
+     */
+    rowDragService?: RowDragService;
+    /**
+     * Batch edit of this table (pending values, shown in the cells) – created by {@link TableScope}.
+     * @since 1.1.96
+     */
+    batchEditService?: BatchEditService;
+    /**
+     * Fill handle of this table – created by {@link TableScope}.
+     * @since 1.1.96
+     */
+    fillHandleService?: FillHandleService;
     constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    /**
+     * The DOM service of this table (all DOM access of the table goes through it).
+     *
+     * @returns {ConvenienceDomService} the service
+     * @since 1.1.95
+     */
+    getDomService(): ConvenienceDomService;
+    /**
+     * The visible body in client (viewport) coordinates – including fixed west/east columns, without the scroll bar –
+     * and the content pixels scrolled out at its top. Row drag computes the row under the pointer with it.
+     *
+     * @returns {{ top: number, height: number, left: number, width: number, contentScrollTop: number }} the geometry
+     * @since 1.1.95
+     */
+    getBodyViewport(): {
+        top: number;
+        height: number;
+        left: number;
+        width: number;
+        contentScrollTop: number;
+    };
+    /**
+     * The rectangle of a body cell in host coordinates (relative to the padding box of the host) – computed from the
+     * row and column positions, also for cells that are not rendered – and the visible part of its area (`clip…`: the
+     * body between header and footer, horizontally the fixed west/east area or the scrollable center).
+     *
+     * @param {number} rowIndex - display index
+     * @param {number} columnIndex - model index
+     * @returns {{ left: number, top: number, width: number, height: number, clipLeft: number, clipRight: number, clipTop: number, clipBottom: number }} the geometry
+     * @since 1.1.96
+     */
+    getBodyCellRectInHost(rowIndex: number, columnIndex: number): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        clipLeft: number;
+        clipRight: number;
+        clipTop: number;
+        clipBottom: number;
+    };
+    /**
+     * The body cell at a point in host coordinates, clamped to the body (a point above the body = row 0, right of the
+     * columns = the last column …) – computed, not read from the DOM.
+     *
+     * @param {number} x - x relative to the host's padding box
+     * @param {number} y - y relative to the host's padding box
+     * @returns {[number, number]} row and column index, `[-1, -1]` without rows or columns
+     * @since 1.1.96
+     */
+    getBodyCellAtHostPoint(x: number, y: number): [number, number];
+    /**
+     * Scroll bar pixels per content pixel: 1, below 1 for a capped scroll height ({@link isScrollHeightCapped}).
+     *
+     * @returns {number} the factor for `scrollTop` changes
+     * @since 1.1.95
+     */
+    getScrollerToContentRatioY(): number;
     isEditing(): boolean;
     /**
      * Resets the editor renderer by clearing its values and state.
@@ -116,6 +193,15 @@ export declare class RenderScope extends EleScope {
      * @return {void}
      */
     repaint(): void;
+    /**
+     * Drops cached, derived values of the area models ({@link AreaModelIf.invalidateDerivedValues}, e.g. the totals of an
+     * {@link AreaModelAggregateFooter}) – called where data may have changed (filter, sorting, editing, `updateCells`,
+     * the public `tableApi.repaint()` / `repaintHard()`), not on scrolling.
+     *
+     * @param {DerivedValuesChangeIf} [change] - the changed rows of an edit or `updateCells()` (models may recompute less)
+     * @since 1.1.94
+     */
+    invalidateAggregates(change?: DerivedValuesChangeIf): void;
     /**
      * Repaints the UI by resetting the size of the wrapper div,
      * adjusting the containers and rows, and performing additional adjustments
@@ -183,6 +269,21 @@ export declare class RenderScope extends EleScope {
      * @returns {void}
      */
     updateCells(events: TableCellUpdateEventIf[], repaintAll?: boolean): void;
+    /**
+     * After `updateCells()` without a repaint: draws the rendered cells of calculated and „Show values as“ columns of
+     * the body again (they depend on the changed cells, e.g. `total = price * quantity` or a share of the total).
+     */
+    protected rerenderCalculatedCells(): void;
+    /**
+     * After `updateCells()` without a repaint: draws the rendered aggregate cells of the group rows of a row grouping
+     * again (they follow the changed rows; labels and counts don't change – a moved row repaints the whole table).
+     */
+    protected rerenderGroupRowCells(): void;
+    /**
+     * After `updateCells()` without a repaint: draws the rendered cells of a footer with cached totals again (only if the
+     * footer implements {@link AreaModelIf.invalidateDerivedValues}, and not if the events changed the footer itself).
+     */
+    protected rerenderDerivedFooterCells(events: TableCellUpdateEventIf[]): void;
     /**
      * Rerenders the content of a table cell based on the given parameters.
      *
@@ -360,11 +461,48 @@ export declare class RenderScope extends EleScope {
      *
      * @protected
      *
-     * @returns {0 | 1} The column index of the tree arrow column.
-     *                Returns 0 if the checkbox is not visible,
-     *                otherwise returns 1.
+     * @returns {number} The column index of the tree arrow column: the first data column (0, behind a row number
+     *                column 1), one more with a visible row checkbox column.
+     */
+    protected getTreeArrowColumnIndex(): number;
+    /**
+     * Index of the first column that is not a row number column: 1 behind a {@link RowNumberColumnDef}, otherwise 0.
+     * The checkbox of `showCheckboxWihoutExtraColumn` and the tree arrow are bound to it.
+     *
+     * @returns {number} 0 or 1
+     * @since 1.1.93
+     */
+    getFirstDataColumnIndex(): number;
+    /** false for a row number column: it has no resize handle (its width follows the numbers). */
+    protected isColumnResizable(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
+     * a rendered number cell in the next render pass.
+     */
+    private rowNumberWidth?;
+    /** true while the containers are adjusted to a new row number width (no second change in that nested pass). */
+    private adjustingRowNumberWidth;
+    /** the approximate first width is measured again once (see adjustAfterScrolling). */
+    private rowNumberRemeasureScheduled;
+    /**
+     * Fits the width of a leading row number column ({@link RowNumberColumnDef}) to its largest number. Cheap on every
+     * render pass: only the text of the largest number is compared; it is measured (canvas) only when it changed.
+     *
+     * @returns {boolean} true if the width changed (the containers must be adjusted)
+     * @since 1.1.93
+     */
+    protected adjustRowNumberColumnWidth(): boolean;
+    /** A rendered label of a number cell – its font and padding are what the numbers need. */
+    private findRowNumberLabel;
+    /**
+     * Width in px of a row number text: with the font and padding of a rendered number cell label; before the first
+     * number cell exists with the font of the host and 6 px padding on each side (then `approximate` is true).
+     * Digits are measured as "0" (tabular figures: all digits are as wide as the widest).
+     *
+     * @returns {[number, boolean]} the width and whether it is approximate
      */
-    protected getTreeArrowColumnIndex(): 0 | 1;
+    protected measureRowNumberText(text: string): [number, boolean];
     protected addAndRenderCellDiv({ areaModel, areaIdent, sideIdent, rowIndex, index, left, width, height, top, parent, lastRowOfModel }: ArgsRenderCellDiv): [HTMLDivElement, RendererCleanupFnType | undefined];
     /**
      * Applies CSS classes to an HTML element.

package/lib/table/renderer/aggregate-cell-renderer.d.ts

@@ -0,0 +1,27 @@
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { CellRendererIf } from './cell-render.if.js';
+import { DomServiceIf } from '../service/dom-service.if.js';
+import { AreaIdent } from '../data/tablemodel/area-ident.type.js';
+import { RendererCleanupFnType } from './renderer-cleanup-fn.type.js';
+
+/**
+ * Writes the formatted text of a cell (`areaModel.getTextValueAt`) as a text node – never as HTML – in the label
+ * structure of a normal cell (`.ge-table-label-div > .ge-table-label`). {@link AreaModelAggregateFooter} uses it for
+ * its results (`"1,234.5"` instead of the raw `1234.4999999`) and labels when the column has no footer renderer.
+ *
+ * @example
+ * // an own footer model that formats in getTextValueAt and shows that text
+ * class MyFooter extends AreaModel {
+ *   private readonly renderer = new AggregateCellRenderer();
+ *   override getCellRenderer(_row: number, _col: number): CellRendererIf { return this.renderer; }
+ *   override getTextValueAt(_row: number, _col: number): string { return "Σ 42"; }
+ * }
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare class AggregateCellRenderer implements CellRendererIf {
+    /** Marker (works across copies of the core). */
+    readonly type = "AggregateCellRenderer";
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/renderer/edit/input-cell-renderer.d.ts

@@ -6,5 +6,5 @@ import { RendererCleanupFnType } from '../renderer-cleanup-fn.type.js';
 
 /** @category Renderers & editing */
 export declare class InputCellRenderer implements CellRendererIf {
-    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
 }

package/lib/table/renderer/edit/select-cell-renderer.d.ts

@@ -10,5 +10,5 @@ export declare class SelectCellRenderer implements CellRendererIf {
     protected options: ValueLabelIf[];
     constructor(options: ValueLabelIf[]);
     static create(values: string[]): SelectCellRenderer;
-    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
 }

package/lib/table/renderer/row-number-cell-renderer.d.ts

@@ -0,0 +1,27 @@
+import { AreaModelIf } from '../data/tablemodel/areamodel/area-model.if.js';
+import { CellRendererIf } from './cell-render.if.js';
+import { DomServiceIf } from '../service/dom-service.if.js';
+import { AreaIdent } from '../data/tablemodel/area-ident.type.js';
+import { RendererCleanupFnType } from './renderer-cleanup-fn.type.js';
+import { RowNumberColumnDef } from '../data/common/row-number-column-def.js';
+
+/**
+ * Renders the number of a body row – the body renderer of {@link RowNumberColumnDef}. The text is set as a text node
+ * (never as HTML), in the same label structure as a normal cell (`.ge-table-label-div > .ge-table-label`).
+ *
+ * The table uses it for a `RowNumberColumnDef` with every body model (also own {@link AreaModel}s without renderers).
+ *
+ * @example
+ * const columnDef = new RowNumberColumnDef();
+ * const renderer = columnDef.rendererMap.body; // a RowNumberCellRenderer
+ *
+ * @since 1.1.93
+ * @category Row numbers
+ */
+export declare class RowNumberCellRenderer implements CellRendererIf {
+    private readonly columnDef;
+    /** Marker (works across copies of the core). */
+    readonly type = "RowNumberCellRenderer";
+    constructor(columnDef: Pick<RowNumberColumnDef, "getRowNumberText">);
+    render(cellDiv: HTMLDivElement, rowIndex: number, columnIndex: number, areaIdent: AreaIdent, areaModel: AreaModelIf, _cellValue: any, domService: DomServiceIf): RendererCleanupFnType | undefined;
+}

package/lib/table/row-drag/move-rows.d.ts

@@ -0,0 +1,157 @@
+import { RowDropTargetIf } from './row-drop-target.if.js';
+import { TreeRowIf } from '../data/common/tree-row-if.js';
+
+/**
+ * Sorted, unique row indices inside `0 … rowCount - 1` (the order of the dragged rows is their display order).
+ *
+ * @param {number[]} rowIndices - any indices, e.g. from a selection
+ * @param {number} rowCount - number of rows
+ * @returns {number[]} a new, ascending array
+ *
+ * @example
+ * normalizeRowIndices([5, 2, 2, 99, -1], 10);   // [2, 5]
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function normalizeRowIndices(rowIndices: readonly number[], rowCount: number): number[];
+/**
+ * The index in front of which the rows are inserted (before the move): `"after"` row 7 = in front of row 8.
+ * `"inside"` counts like `"after"` (flat lists have no children).
+ *
+ * @param {RowDropTargetIf} target - the drop target
+ * @returns {number} the insert position, 0 … rowCount
+ *
+ * @example
+ * getInsertBeforeIndex({ rowIndex: 7, position: "after" });    // 8
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function getInsertBeforeIndex(target: RowDropTargetIf): number;
+/**
+ * The index of the first moved row after a move in a flat list: the insert position minus the moved rows in front
+ * of it. A target inside the moved rows (or right next to them) returns their current index – nothing changes.
+ *
+ * @param {number[]} rowIndices - ascending, unique row indices ({@link normalizeRowIndices})
+ * @param {RowDropTargetIf} target - the drop target
+ * @returns {number} the new index of the first moved row, -1 without rows
+ *
+ * @example
+ * // D1: row 3 (index 2) dropped between row 7 and 8 → it is row 7 (index 6) afterwards
+ * calcMoveToIndex([2], { rowIndex: 6, position: "after" });   // 6
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function calcMoveToIndex(rowIndices: readonly number[], target: RowDropTargetIf): number;
+/**
+ * Moves items of an array **in place** (like `Array.prototype.sort`): the items at `indices` keep their order and are
+ * inserted in front of `insertBefore` (an index of the array before the move, `array.length` = at the end).
+ *
+ * @param {T[]} array - the array to change
+ * @param {number[]} indices - ascending, unique indices ({@link normalizeRowIndices})
+ * @param {number} insertBefore - 0 … array.length
+ * @returns {number} the new index of the first moved item (-1 if nothing was given)
+ *
+ * @example
+ * const list = ["a", "b", "c", "d", "e"];
+ * moveArrayItems(list, [1, 3], 5);   // 3
+ * list;                              // ["a", "c", "e", "b", "d"]
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function moveArrayItems<T>(array: T[], indices: readonly number[], insertBefore: number): number;
+/**
+ * The dragged tree rows without the ones that travel with an ancestor (a child of a dragged node moves with it).
+ *
+ * @param {TreeRowIf<S>[]} rows - dragged rows in display order
+ * @returns {TreeRowIf<S>[]} the topmost dragged rows, same order
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function getTopmostTreeRows<S>(rows: readonly TreeRowIf<S>[]): TreeRowIf<S>[];
+/**
+ * True if the tree rows can be dropped at the target row: the target is none of the dragged rows and no descendant
+ * of them (a node cannot become its own child – no cycle).
+ *
+ * @param {TreeRowIf<S>[]} rows - dragged rows
+ * @param {TreeRowIf<S>} targetRow - the row under the drop marker
+ * @returns {boolean} false for a cycle
+ *
+ * @example
+ * const treeModel = tableModel.getBodyModel() as AreaModelTree<OrderNode>;
+ * const node = treeModel.rows[0];
+ * canMoveTreeRows([node], node.children?.[0]);   // false – into its own child
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function canMoveTreeRows<S>(rows: readonly TreeRowIf<S>[], targetRow: TreeRowIf<S> | undefined): boolean;
+/**
+ * Moves tree rows **in place**: in front of / behind `targetRow` (siblings, same parent) or `"inside"` it (last
+ * children; the target is expanded). Children travel with their parent; `parent` and `deep` are updated.
+ *
+ * @param {TreeRowIf<S>[]} roots - the top-level rows (e.g. `AreaModelTree.rows`)
+ * @param {TreeRowIf<S>[]} rows - dragged rows in display order
+ * @param {TreeRowIf<S>} targetRow - the row under the drop marker
+ * @param {"before" | "after" | "inside"} position - where to drop
+ * @returns {boolean} false if nothing was moved (cycle, no rows)
+ *
+ * @example
+ * const treeModel = tableModel.getBodyModel() as AreaModelTree<OrderNode>;
+ * moveTreeRows(treeModel.rows, [treeModel.rows[2]], treeModel.rows[0], "inside");   // 3rd root → child of the 1st
+ * treeModel.recalcVisibleTreeRows();
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function moveTreeRows<S>(roots: TreeRowIf<S>[], rows: readonly TreeRowIf<S>[], targetRow: TreeRowIf<S>, position: RowDropTargetIf["position"]): boolean;
+/**
+ * Flat area models: true if the dragged rows can be moved – all rows are displayed (no filter hides one), the target
+ * row exists and is not `"inside"`.
+ *
+ * @param {number} displayedCount - displayed rows (`getRowCount()`)
+ * @param {number} allCount - all rows (`getUnfilteredRowCount()`)
+ * @param {number[]} rowIndices - display indices of the dragged rows
+ * @param {RowDropTargetIf} target - the drop target
+ * @returns {boolean} true if a move is possible
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function canMoveFlatRows(displayedCount: number, allCount: number, rowIndices: readonly number[], target: RowDropTargetIf): boolean;
+/**
+ * Flat area models: moves the rows in the displayed array and writes the new order back to the array of all rows –
+ * both in place. Used by `AreaModelObjectArray` and `AreaModelArrayOfArrays`.
+ *
+ * @param {T[]} displayed - displayed rows (display order)
+ * @param {T[]} all - all rows (same rows – no filter hides one)
+ * @param {number[]} rowIndices - display indices of the dragged rows
+ * @param {RowDropTargetIf} target - the drop target
+ * @returns {boolean} true if moved
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function moveFlatRows<T>(displayed: T[], all: T[], rowIndices: readonly number[], target: RowDropTargetIf): boolean;
+/**
+ * The row at a content position (y in px from the top of all body rows): constant row heights are computed directly,
+ * variable ones by a binary search over the row tops. Positions above / below the rows give the first / last row.
+ *
+ * @param {number} contentY - y in content pixels
+ * @param {number} rowCount - number of rows (> 0)
+ * @param {(rowIndex: number) => number} getYPosByRowIndex - top of a row in content pixels (`AreaModelIf.getYPosByRowIndex`)
+ * @param {number} [constantRowHeight] - the height of every row, if they are all equal (`AreaModelIf.getConstantRowHeight`)
+ * @returns {number} the row index, 0 … rowCount - 1
+ *
+ * @example
+ * const body = tableModel.getBodyModel();
+ * const rowIndex = findRowIndexAtY(1234, body.getRowCount(), i => body.getYPosByRowIndex(i), body.getConstantRowHeight?.());
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare function findRowIndexAtY(contentY: number, rowCount: number, getYPosByRowIndex: (rowIndex: number) => number, constantRowHeight?: number): number;

package/lib/table/row-drag/row-drag-options.d.ts

@@ -0,0 +1,28 @@
+import { RowDragOptionsIf } from './row-drag-options.if.js';
+
+/**
+ * The defaults of {@link RowDragOptionsIf}.
+ *
+ * @example
+ * const options = RowDragOptions.create({ managed: false });
+ * options.autoScrollZoneInPx;   // 40
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export declare class RowDragOptions implements RowDragOptionsIf {
+    managed: boolean;
+    multiRow: boolean;
+    treeDropInside: boolean;
+    dragThresholdInPx: number;
+    autoScrollZoneInPx: number;
+    autoScrollMaxSpeedInPx: number;
+    ghostText?: (rows: any[]) => string;
+    /**
+     * The defaults, overridden by the given values (`undefined` keeps the default).
+     *
+     * @param {Partial<RowDragOptionsIf>} [options] - e.g. `tableOptions.rowDragOptions`
+     * @returns {RowDragOptionsIf} complete options
+     */
+    static create(options?: Partial<RowDragOptionsIf>): RowDragOptionsIf;
+}

package/lib/table/row-drag/row-drag-options.if.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Options of row dragging ({@link TableOptionsIf.rowDragOptions}). Rows get a drag handle in every column with
+ * {@link ColumnDefIf.rowDrag} (or `TableFactory.createTableModel({ rows, rowDrag: true })`).
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   rowDragOptions: { managed: false, autoScrollMaxSpeedInPx: 40 }   // events only – the app moves the rows
+ * };
+ *
+ * @category Row drag
+ * @since 1.1.95
+ */
+export interface RowDragOptionsIf {
+    /**
+     * `true` (default): the table moves the rows itself (`AreaModelIf.moveRows`) – only while the table is neither
+     * sorted (a column with sort state asc/desc) nor filtered. `false`: the table only reports the drag
+     * (`onRowDragStart/Move/End`), the app moves the rows (e.g. after the server confirmed), always allowed.
+     */
+    managed: boolean;
+    /** `true` (default): grabbing a selected row drags all rows with a selection (their order stays). */
+    multiRow: boolean;
+    /** `true` (default): tree – dropping on the middle of a row makes the rows its children. */
+    treeDropInside: boolean;
+    /** Distance in px the pointer has to move before a drag starts (default 4) – below it is a click on the handle. */
+    dragThresholdInPx: number;
+    /** Height in px of the zone at the top and bottom edge of the body that scrolls automatically (default 40). */
+    autoScrollZoneInPx: number;
+    /** Maximum auto-scroll speed in px per animation frame (default 24). */
+    autoScrollMaxSpeedInPx: number;
+    /**
+     * Text of the drag ghost. Default: the text of the handle cell of the first row, "(+2)" for two more rows.
+     * The text is shown as text (never as HTML).
+     */
+    ghostText?: (rows: any[]) => string;
+}