@guiexpert/table 1.1.97 → 1.1.98

package/lib/table/crud/crud-object-edit.d.ts

@@ -17,6 +17,8 @@
 export declare class CrudObjectEdit<T extends Record<string, any>> {
     private idKey;
     dialogTitle: string;
+    /** Writing direction of the dialog (`dir`) – the CRUD factory sets the direction of the table. @since 1.1.98 */
+    direction?: "ltr" | "rtl";
     private object;
     /** Property path of every input (index = `data-field-index`) – a key may contain a dot itself. */
     private fieldPaths;

package/lib/table/crud/crud-object-view.d.ts

@@ -5,6 +5,8 @@
  * @category CRUD
  */
 export declare class CrudObjectView<T extends Record<string, any>> {
+    /** Writing direction of the dialog (`dir`) – the CRUD factory sets the direction of the table. @since 1.1.98 */
+    direction?: "ltr" | "rtl";
     private object;
     constructor(obj: T);
     openDialog(): void;

package/lib/table/crud/crud-table-model-factory.d.ts

@@ -59,6 +59,8 @@ export declare class CrudTableModelFactory implements ActionEventListenerIf {
      * While a request runs, the table shows its loading overlay ({@link TableApi.showLoadingOverlay}, since 1.1.92).
      * A failed request is logged with `console.error`; the table stays unchanged.
      */
+    /** The dialogs live outside the host: they get the writing direction of the table (since 1.1.98). */
+    private withDirection;
     onActionEvent(actionEvent: ActionEventIf): void;
     /** `createItem` without the id property (the server assigns it), then shows the new row. */
     private createItem;

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

@@ -1,3 +1,4 @@
+import { TableDirection } from '../../rtl/table-direction.type.js';
 import { MasterDetailOptionsIf } from '../../master-detail/master-detail-options.if.js';
 import { DefaultRowHeightsIf } from './default-row-heights.if.js';
 import { TableOptionsIf } from './table-options.if.js';
@@ -88,4 +89,9 @@ export declare class TableOptions implements TableOptionsIf {
     fillHandle?: boolean | Partial<FillHandleOptionsIf>;
     masterDetail?: Partial<MasterDetailOptionsIf>;
     batchEdit?: boolean | Partial<BatchEditOptionsIf>;
+    /**
+     * Writing direction (`"ltr"` | `"rtl"` | `"auto"`). Not set = `"ltr"`; a nested table (master/detail) without its
+     * own value takes the direction of the outer table. @since 1.1.98
+     */
+    direction?: TableDirection;
 }

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

@@ -17,6 +17,7 @@ import { HeaderGroupOptionsIf } from './header-group-options.if.js';
 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';
 
 /**
  * Represents the options for configuring a table.
@@ -379,6 +380,22 @@ export interface TableOptionsIf {
      * @since 1.1.97
      */
     masterDetail?: Partial<MasterDetailOptionsIf>;
+    /**
+     * Writing direction: `"ltr"` (default), `"rtl"` for Arabic, Hebrew, Persian, Urdu … (first column on the right,
+     * horizontal scrolling, fixed columns, tree indent, resize handles and arrow keys mirrored) or `"auto"` (the
+     * direction of the page: `dir="rtl"` on `<html>` or a parent element). Read once when the table is built – a new
+     * options object rebuilds the table in the wrappers.
+     *
+     * In right-to-left, the "left" and "right" in names of the API mean **start** and **end**:
+     * `fixedLeftColumnCount` fixes columns at the start (right), `fixedRightColumnCount` at the end (left),
+     * `ge-table-text-align-left` aligns to the start. The table sets `dir` on its host element (also `dir="ltr"`).
+     *
+     * @example
+     * const tableOptions: TableOptionsIf = { ...new TableOptions(), direction: "rtl" };
+     *
+     * @since 1.1.98
+     */
+    direction?: TableDirection;
     /**
      * The state the table starts with: column layout, sorting, tree, checked and selected rows … – e.g. loaded from
      * your server ({@link TableApi.getState}, {@link EventListenerIf.onStateChanged}). A state stored by

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

@@ -7,6 +7,7 @@ import { AriaIds } from './aria/aria-ids.js';
 import { AreaIdent } from './data/tablemodel/area-ident.type.js';
 import { SideIdent } from './data/side-ident.type.js';
 import { TableOverlay } from './overlay/table-overlay.js';
+import { ResolvedTableDirection } from './rtl/table-direction.type.js';
 
 /**
  * Represents a store for HTML elements.
@@ -53,7 +54,43 @@ export declare class EleScope {
     readonly ariaIds: AriaIds;
     /** The overlay layer over the body ("Loading…", "No rows to show"). @since 1.1.92 */
     readonly tableOverlay: TableOverlay;
+    /**
+     * The resolved writing direction of the table ({@link TableOptionsIf.direction}; `"auto"` is decided when the table
+     * is built). @since 1.1.98
+     */
+    readonly direction: ResolvedTableDirection;
     constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, dom: ConvenienceDomService, tableOptions: TableOptionsIf);
+    /**
+     * Whether the table runs from right to left ({@link TableOptionsIf.direction}).
+     *
+     * @returns {boolean} true for `"rtl"` (also a resolved `"auto"`)
+     * @since 1.1.98
+     */
+    isRtl(): boolean;
+    /**
+     * The horizontal scroll position of the body as distance from the **start** (≥ 0) – `scrollLeft`, in
+     * right-to-left `-scrollLeft`.
+     *
+     * @returns {number} px
+     * @since 1.1.98
+     */
+    getViewportScrollLeft(): number;
+    /**
+     * Sets the horizontal scroll position of the body as distance from the **start** (see {@link getViewportScrollLeft}).
+     *
+     * @param {number} x - px from the start
+     * @since 1.1.98
+     */
+    setViewportScrollLeft(x: number): void;
+    /**
+     * A client x coordinate (e.g. `PointerEvent.clientX`) as x in the host from the start of its padding box – the
+     * coordinates in which the table positions everything (right-to-left: from the right edge).
+     *
+     * @param {number} clientX - x in client (viewport) coordinates
+     * @returns {number} px from the start
+     * @since 1.1.98
+     */
+    clientXToHostX(clientX: number): number;
     /**
      * Shows the overlay that fits the current state (requested by the API, or "no rows" for an empty body).
      * Overwritten in {@link RenderScope}.

package/lib/table/rtl/rtl-util.d.ts

@@ -0,0 +1,126 @@
+import { ResolvedTableDirection, TableDirection } from './table-direction.type.js';
+
+/**
+ * Decides the direction of a table: `"rtl"` and `"ltr"` as given, `"auto"` from the computed `direction` of the host
+ * (inherited from `<html dir="rtl">` or any parent) – for a host that is not in the document yet from the nearest
+ * `dir` attribute of the host or a parent. Missing (`undefined`) = `"ltr"`.
+ *
+ * Must be called before the table sets the `dir` attribute of the host.
+ *
+ * @param {TableDirection | undefined} direction - the option ({@link TableOptionsIf.direction})
+ * @param {HTMLElement} [host] - the host element of the table (needed for `"auto"`)
+ * @returns {ResolvedTableDirection} `"ltr"` or `"rtl"`
+ *
+ * @example
+ * resolveTableDirection("auto", document.getElementById("table")!); // "rtl" on a page with <html dir="rtl">
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function resolveTableDirection(direction: TableDirection | undefined, host?: HTMLElement): ResolvedTableDirection;
+/**
+ * The horizontal scroll position of an element as distance from the **start** (≥ 0): in left-to-right `scrollLeft`,
+ * in right-to-left `-scrollLeft` (browsers report 0 at the right start and negative values when scrolled to the left,
+ * CSSOM View).
+ *
+ * @param {{ scrollLeft: number }} element - a scroll container
+ * @param {boolean} rtl - the container is right-to-left
+ * @returns {number} px from the start
+ *
+ * @example
+ * const fromStart = getLogicalScrollLeft(tableApi.getTableScope().scrollViewport, tableApi.getDirection() === "rtl");
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function getLogicalScrollLeft(element: {
+    scrollLeft: number;
+}, rtl: boolean): number;
+/**
+ * Sets the horizontal scroll position of an element as distance from the **start** (see {@link getLogicalScrollLeft}).
+ *
+ * @param {{ scrollLeft: number }} element - a scroll container
+ * @param {number} x - px from the start
+ * @param {boolean} rtl - the container is right-to-left
+ *
+ * @example
+ * setLogicalScrollLeft(tableApi.getTableScope().scrollViewport, 0, true); // back to the (right) start
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function setLogicalScrollLeft(element: {
+    scrollLeft: number;
+}, x: number, rtl: boolean): void;
+/**
+ * The horizontal scroll position for `element.scrollTo(…)` – physical, i.e. negative in right-to-left.
+ *
+ * @param {number} x - px from the start
+ * @param {boolean} rtl - right-to-left
+ * @returns {number} the value for `scrollLeft` / `scrollTo()`
+ *
+ * @example
+ * tableApi.getTableScope().scrollViewport.scrollTo(toPhysicalScrollLeft(200, true), 0); // 200 px from the right start
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function toPhysicalScrollLeft(x: number, rtl: boolean): number;
+/**
+ * Whether a scroll container can still scroll horizontally by `dx` (physical: `dx > 0` = to the right) – for
+ * left-to-right and right-to-left containers alike.
+ *
+ * @param {{ scrollLeft: number, scrollWidth: number, clientWidth: number }} element - a scroll container
+ * @param {number} dx - physical delta (e.g. `WheelEvent.deltaX`)
+ * @param {boolean} rtl - the container is right-to-left
+ * @returns {boolean} true if a scroll by `dx` would move the content
+ *
+ * @example
+ * host.addEventListener("wheel", e => {
+ *   const takesIt = canScrollHorizontally(host, e.deltaX, getComputedStyle(host).direction === "rtl");
+ *   console.info(takesIt ? "the element scrolls itself" : "pass it on");
+ * });
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function canScrollHorizontally(element: {
+    scrollLeft: number;
+    scrollWidth: number;
+    clientWidth: number;
+}, dx: number, rtl: boolean): boolean;
+/**
+ * A client x coordinate (e.g. `PointerEvent.clientX`) as position in a box measured from the box's **start**:
+ * left-to-right from its left edge, right-to-left from its right edge.
+ *
+ * @param {number} clientX - x in client (viewport) coordinates
+ * @param {number} boxLeft - the left edge of the box in client coordinates
+ * @param {number} boxWidth - the width of the box
+ * @param {boolean} rtl - right-to-left
+ * @returns {number} px from the start of the box
+ *
+ * @example
+ * host.addEventListener("pointerdown", e => {
+ *   const r = host.getBoundingClientRect();
+ *   console.info(toLogicalX(e.clientX, r.left + host.clientLeft, host.clientWidth, true)); // px from the right edge
+ * });
+ *
+ * @since 1.1.98
+ * @category Utilities
+ */
+export declare function toLogicalX(clientX: number, boxLeft: number, boxWidth: number, rtl: boolean): number;
+/**
+ * Swaps the arrow keys "left" and "right" in a harmonized shortcut (e.g. `"cmd left"` → `"cmd right"`) – the
+ * keyboard handling of a right-to-left table, so that → moves backwards in reading direction.
+ *
+ * @param {string} shortcut - a harmonized shortcut (`harmonizeShortcut`)
+ * @returns {string} the shortcut with swapped arrow keys
+ *
+ * @example
+ * mirrorArrowKeys("left");       // "right"
+ * mirrorArrowKeys("cmd right");  // "cmd left"
+ *
+ * @since 1.1.98
+ * @category Keyboard
+ */
+export declare function mirrorArrowKeys(shortcut: string): string;

package/lib/table/rtl/table-direction.type.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The writing direction of a table ({@link TableOptionsIf.direction}):
+ *
+ * - `"ltr"` (default): left to right – the first column on the left.
+ * - `"rtl"`: right to left (Arabic, Hebrew, Persian, Urdu …) – the first column on the right, horizontal scrolling,
+ *   fixed columns, tree indent, resize handles and arrow keys mirrored.
+ * - `"auto"`: the direction of the page where the table is created (`dir="rtl"` on `<html>`, a parent element or the
+ *   host itself → `"rtl"`).
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = { ...new TableOptions(), direction: "rtl" };
+ *
+ * @since 1.1.98
+ * @category Options
+ */
+export type TableDirection = "ltr" | "rtl" | "auto";
+/**
+ * A resolved writing direction – what {@link TableApi.getDirection} returns (`"auto"` is already decided).
+ *
+ * @since 1.1.98
+ * @category Options
+ */
+export type ResolvedTableDirection = "ltr" | "rtl";

package/lib/table/service/convenience-dom.service.d.ts

@@ -10,6 +10,7 @@ import { SideIdent } from '../data/side-ident.type.js';
 import { SortState } from '../data/common/sort-state.type.js';
 import { SortedOptionsIf } from '../data/options/sorted-options.if.js';
 import { HtmlStyle } from './data/html-style.type.js';
+import { ResolvedTableDirection } from '../rtl/table-direction.type.js';
 
 /** @category DOM */
 export interface AddColumnDivPara {
@@ -37,7 +38,54 @@ export declare class ConvenienceDomService {
     readonly domService: DomServiceIf;
     /** Width of the focus frame of a cell in px (WCAG 2.4.7: visible focus, not only a color). @since 1.1.91 */
     static focusBorderWidthInPx: number;
+    /** Right-to-left: `left` is written as `right` and vice versa (see {@link setDirection}). */
+    private rtl;
+    /** The physical CSS property of the inline start (`left`, right-to-left `right`). */
+    private startKey;
+    /** The physical CSS property of the inline end (`right`, right-to-left `left`). */
+    private endKey;
     constructor(domService: DomServiceIf);
+    /**
+     * Sets the writing direction of the table. All positions of the table are computed from the **start** of a row
+     * (x = 0 is the first column); in right-to-left this service writes them as `right` instead of `left` – in
+     * {@link setStyle}, {@link applyStyle}, {@link applyStyleInPx} and all `add…` methods – so that the whole table is
+     * mirrored. Called once by the table before anything is positioned.
+     *
+     * @param {ResolvedTableDirection} direction - `"ltr"` or `"rtl"`
+     *
+     * @example
+     * const dom = new ConvenienceDomService(new SimpleDomService());
+     * dom.setDirection("rtl");
+     * const div = document.createElement("div");
+     * dom.setStyle(div, "left", "20px"); // div.style.right = "20px"
+     *
+     * @since 1.1.98
+     */
+    setDirection(direction: ResolvedTableDirection): void;
+    /**
+     * The writing direction set with {@link setDirection} (default `"ltr"`).
+     *
+     * @returns {ResolvedTableDirection} `"ltr"` or `"rtl"`
+     * @since 1.1.98
+     */
+    getDirection(): ResolvedTableDirection;
+    /**
+     * The physical CSS property for a logical position key: in right-to-left `left` ↔ `right`, everything else as is.
+     *
+     * @param {string} key - a CSS property
+     * @returns {string} the property to write
+     * @since 1.1.98
+     */
+    toPhysicalStyleKey(key: string): string;
+    /**
+     * The position of an element from the inline start in px, as written by this service (`style.left`, right-to-left
+     * `style.right`); 0 if it has none.
+     *
+     * @param {HTMLElement} ele - an element positioned by this service
+     * @returns {number} px
+     * @since 1.1.98
+     */
+    getInlineStart(ele: HTMLElement): number;
     setStyle(el: any, style: string, value: any): any;
     applyStyle(ele: HTMLDivElement, style: HtmlStyle): HTMLDivElement;
     applyDisplayNoneStyle(ele: HTMLDivElement): HTMLDivElement;
@@ -46,7 +94,7 @@ export declare class ConvenienceDomService {
     applyStylePosistionRelative(ele: HTMLDivElement): HTMLDivElement;
     applyStylePosistionAbsolute(ele: HTMLDivElement): HTMLDivElement;
     applyStyleFullSize(ele: HTMLDivElement): HTMLDivElement;
-    applyStyleOverflowAuto(overflowX: "scroll" | "auto" | undefined, overflowY: "scroll" | "auto" | undefined, ele: HTMLDivElement): HTMLDivElement;
+    applyStyleOverflowAuto(overflowX: "auto" | "scroll" | undefined, overflowY: "auto" | "scroll" | undefined, ele: HTMLDivElement): HTMLDivElement;
     applyStyleNoPadding(ele: HTMLDivElement): HTMLDivElement;
     appendRelativeChildDiv(parent: HTMLDivElement): DivScope;
     appendText(parent: HTMLDivElement, text: string): HTMLElement;

package/lib/table/service/excel-export-options.if.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Options of an Excel export ({@link ExcelService.downloadExcel}, {@link ExcelService.createExcelBlob}).
+ *
+ * @example
+ * // an Arabic sheet: column A on the right, like the table
+ * await new ExcelService().downloadExcel(matrix, "sales.xlsx", "", { rightToLeft: true });
+ *
+ * @since 1.1.98
+ * @category Export & clipboard
+ */
+export interface ExcelExportOptionsIf {
+    /**
+     * The worksheet runs from right to left (`<sheetView rightToLeft="1">`): column A on the right.
+     * {@link TableApi.downloadExcel} sets it for a right-to-left table ({@link TableOptionsIf.direction}).
+     */
+    rightToLeft?: boolean;
+}

package/lib/table/service/excel-service.d.ts

@@ -1,3 +1,4 @@
+import { ExcelExportOptionsIf } from './excel-export-options.if.js';
 import { ExcelServiceIf } from './excel-service.if.js';
 
 /**
@@ -32,18 +33,23 @@ export declare class ExcelService implements ExcelServiceIf {
      * @param {Array<Array<any>>} matrix - A 2D array representing the data to be included in the Excel file. Each inner array corresponds to a row in the sheet.
      * @param {string} [filename='file.xlsx'] - The name of the Excel file to be downloaded. Defaults to 'file.xlsx'.
      * @param {string} [author=''] - The author's name to include as metadata in the Excel file. Optional parameter.
+     * @param {ExcelExportOptionsIf} [options] - e.g. `{ rightToLeft: true }` for a sheet from right to left (since 1.1.98)
      * @return {void} Does not return a value.
      * @throws {Error} Throws an error if the input matrix is not a valid 2D array or if the filename is an empty string.
      */
-    downloadExcel(matrix: Array<Array<any>>, filename?: string, author?: string): Promise<void>;
+    downloadExcel(matrix: Array<Array<any>>, filename?: string, author?: string, options?: ExcelExportOptionsIf): Promise<void>;
     /**
      * Creates the .xlsx file as a Blob (compressed), e.g. to upload it instead of downloading it.
      *
      * @example
      * const blob = await new ExcelService().createExcelBlob([["Name", "City"], ["Ann", "Berlin"]]);
      * await fetch("/api/upload", { method: "POST", body: blob });
+     *
+     * @example
+     * // a sheet from right to left (column A on the right), since 1.1.98
+     * const rtlBlob = await new ExcelService().createExcelBlob([["المدينة"], ["الرياض"]], "", { rightToLeft: true });
      */
-    createExcelBlob(matrix: Array<Array<any>>, author?: string): Promise<Blob>;
+    createExcelBlob(matrix: Array<Array<any>>, author?: string, options?: ExcelExportOptionsIf): Promise<Blob>;
     private generateMap;
     private getX1WorksheetsSheet1Xml;
     /** Number format → cell style index (1-based; 0 = default), filled by withNumberFormats() before the sheet is written. */

package/lib/table/service/excel-service.if.d.ts

@@ -1,3 +1,5 @@
+import { ExcelExportOptionsIf } from './excel-export-options.if.js';
+
 /**
  * Writes an Excel file from a matrix of values. The default implementation is {@link ExcelService};
  * pass your own as last argument of the `TableScope` constructor to change how {@link TableApi.downloadExcel} exports.
@@ -6,7 +8,7 @@
  */
 export interface ExcelServiceIf {
     /** Creates the file from `matrix` (rows of values) and hands it to the browser as download. */
-    downloadExcel(matrix: Array<Array<any>>, filename: string, author?: string): void | Promise<void>;
+    downloadExcel(matrix: Array<Array<any>>, filename: string, author?: string, options?: ExcelExportOptionsIf): void | Promise<void>;
     /**
      * True if the service understands cells of the form {@link ExcelFormattedValueIf} (`{ value, numberFormat }`).
      * Only then {@link TableApi.downloadExcel} exports percentages of „Show values as“ columns with the format `0.0%`;

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

@@ -1,3 +1,4 @@
+import { ResolvedTableDirection } from './rtl/table-direction.type.js';
 import { GeOverlayKind } from './overlay/ge-overlay-kind.type.js';
 import { TableStateIf, TableStatePart } from './state/table-state.if.js';
 import { SortState } from './data/common/sort-state.type.js';
@@ -52,6 +53,7 @@ import { CellRange } from './data/common/cell-range.js';
  * | columns | {@link autoResizeColumns}, {@link setColumnWidth}, {@link recalcColumnWidths}, {@link getColumnIndex} |
  * | tree | {@link expandAll}, {@link collapseAll}, {@link setRowExpanded} |
  * | state | {@link getState}, {@link applyState}, {@link resetState} (with {@link TableOptionsIf.autoRestoreOptions}) |
+ * | right-to-left | {@link getDirection} (with {@link TableOptionsIf.direction}) |
  * | lifecycle | {@link destroy} |
  *
  * @example
@@ -218,7 +220,8 @@ export declare class TableApi {
      * This method allows programmatic scrolling of the table viewport to exact pixel positions.
      * It delegates the scrolling operation to the underlying TableScope instance.
      *
-     * @param {number} px - The horizontal pixel coordinate to scroll to. Defaults to 0 (leftmost position).
+     * @param {number} px - The horizontal pixel coordinate to scroll to: px from the start of the row – 0 = the first
+     *   column (leftmost position; right-to-left the rightmost, see {@link TableOptionsIf.direction}). Defaults to 0.
      * @param {number} py - The vertical pixel coordinate to scroll to. Defaults to 0 (topmost position).
      * @returns {void}
      *
@@ -233,7 +236,7 @@ export declare class TableApi {
      * @example
      * // Scroll only vertically, keeping the current horizontal position
      * // (an omitted or undefined px means 0; for rows use scrollToIndex(-1, rowIndex))
-     * tableApi.scrollToPixel(tableApi.getTableScope().scrollViewport.scrollLeft, 300);
+     * tableApi.scrollToPixel(tableApi.getTableScope().getViewportScrollLeft(), 300);
      *
      * @example
      * // Example in a component that needs precise scrolling control
@@ -263,6 +266,23 @@ export declare class TableApi {
      * @see {@link ensureRowIsVisible} - For scrolling to make a specific row visible
      */
     scrollToPixel(px?: number, py?: number): void;
+    /**
+     * The writing direction of the table – {@link TableOptionsIf.direction} with `"auto"` already decided (from the page
+     * when the table was built).
+     *
+     * In `"rtl"` the first column is on the right; positions of the API stay "from the start": {@link scrollToPixel},
+     * {@link GeScrollEvent.scrollLeft} and the scroll part of {@link getState} count from the right edge.
+     *
+     * @returns {ResolvedTableDirection} `"ltr"` or `"rtl"`
+     *
+     * @example
+     * if (tableApi.getDirection() === "rtl") {
+     *   console.info("first column on the right");
+     * }
+     *
+     * @since 1.1.98
+     */
+    getDirection(): ResolvedTableDirection;
     /**
      * Scrolls the table to display the specified row and column indices at the top-left corner of the viewport.
      *

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

@@ -125,6 +125,11 @@ export declare class TableScope extends RenderScope implements OnActionTriggered
     /** Last comparator passed to `sort()`; re-applied after filtering. Cleared by a header sort. */
     private lastSortCompareFn?;
     constructor(hostElement: HTMLDivElement, tableModel: TableModelIf, domService: DomServiceIf, tableOptions: TableOptionsIf, eventListener: EventListenerIf, copyService?: CopyServiceIf, excelService?: ExcelServiceIf);
+    /**
+     * The options of a nested table (master/detail `ctx.createTable()`): as given; without an own `direction` in a
+     * right-to-left table an object that reads everything else from the given options (prototype) and adds `"rtl"`.
+     */
+    private nestedTableOptions;
     /** Time of the last Tab key press on the page (the host is focused right after it). */
     private lastTabKeyTime;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guiexpert/table",
-  "version": "1.1.97",
+  "version": "1.1.98",
   "license": "MIT",
   "author": "Dr. Marc Kronberg <info@gui.expert> (https://gui.expert)",
   "repository": {