@guiexpert/table 1.1.90 → 1.1.92

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

@@ -0,0 +1,158 @@
+import { TableScope } from '../table-scope.js';
+import { TableStateIf, TableStatePart } from './table-state.if.js';
+
+/**
+ * Collects and applies the {@link TableStateIf} of one table, stores it ({@link AutoRestoreOptionsIf}) and reports
+ * changes ({@link EventListenerIf.onStateChanged}). One instance per {@link TableScope} (`tableScope.stateService`);
+ * use the methods of {@link TableApi} instead.
+ *
+ * Changes are only marked ({@link markDirty}); after {@link TableOptionsIf.stateChangedDebounceDelay} the dirty
+ * parts are computed once, compared with the last reported state, stored with ONE storage write and reported with
+ * ONE event – no storage access per scroll frame.
+ *
+ * @category Internals
+ * @since 1.1.92
+ */
+export declare class TableStateService {
+    private readonly scope;
+    /** Suffix of the storage key: `<key>tableState`. */
+    static readonly STORAGE_SUFFIX = "tableState";
+    /** Parts that need a pass over all rows: no baseline at the start, computed only when they are used. */
+    private static readonly EXPENSIVE;
+    /** The restore of the first `firstInit()` is running (or has not finished). */
+    private restoring;
+    private started;
+    private destroyed;
+    private readonly dirty;
+    private timer?;
+    /** JSON per part of the last reported (or restored) state. */
+    private readonly lastReported;
+    /** The last reported state – a flush recomputes only the dirty parts. */
+    private reported;
+    /** The scroll position of the last reported state (a number compare – no string prefixes). */
+    private reportedScroll?;
+    /** The last stored JSON (no second write for the same state). */
+    private lastPersisted?;
+    /** The keys before 1.1.92 are removed with the first save of this table. */
+    private legacyRemoved;
+    /** Properties of the sorted columns, primary key first (the header shows only the sort states). */
+    private sortPriority;
+    /** The widths of the column definitions before anything was restored (a width is stored only if it changed). */
+    private readonly initialWidths;
+    /** The state right after the table was built – {@link resetState}. */
+    private defaultState?;
+    /** The state applied at the start: stored state over `initialState`. */
+    private startState;
+    private custom;
+    private warnedNoRowObject;
+    private warnedNoId;
+    constructor(scope: TableScope);
+    /**
+     * First `firstInit()` only, before `tableModel.init()`: reads the start state and applies the header groups
+     * (they decide which column definitions exist).
+     */
+    initBeforeModel(): void;
+    /** After `tableModel.init()`: remembers the defaults, applies the column layout. */
+    initAfterModel(): void;
+    /** After the external filter: tree, sorting, checked rows, selection. */
+    initAfterFilter(): void;
+    /** After the layout (scroll height known): scroll position; the restore is finished. */
+    initAfterLayout(): void;
+    /**
+     * The current state (all parts, or the given ones). Parts that do not apply to the table are left out (e.g. `tree`
+     * without a tree, `columns` without column definitions).
+     *
+     * @param {TableStatePart[]} [parts] - the parts to read, default: all
+     * @returns {TableStateIf} the state
+     */
+    getState(parts?: readonly TableStatePart[]): TableStateIf;
+    /**
+     * Applies the parts of a state (only the parts it contains, optionally only the given ones) and repaints.
+     * Reports the change with `onStateChanged` and stores it.
+     *
+     * @param {Partial<TableStateIf>} state - the state
+     * @param {TableStatePart[]} [parts] - only these parts
+     */
+    applyState(state: Partial<TableStateIf>, parts?: readonly TableStatePart[]): void;
+    /**
+     * Back to the state right after the table was built (the code's column layout, sort icons, header groups, without
+     * the restored state; tree, checked rows and selection when they are stored or were given as `initialState`),
+     * scrolled to the top, custom data removed – and removes the stored state.
+     */
+    resetState(): void;
+    /** Sets the part `custom` (data of the application). */
+    setCustomState(custom: unknown): void;
+    /** The column was sorted by a header click / `sortByColumn` – it becomes the primary sort key. */
+    sortedByColumn(property: string | undefined): void;
+    /**
+     * Marks a part as changed. After {@link TableOptionsIf.stateChangedDebounceDelay} the state is stored and
+     * reported – only if it really changed. No effect before the table is built.
+     *
+     * @param {TableStatePart} part - the changed part
+     */
+    markDirty(part: TableStatePart): void;
+    /** Called after each render pass: marks the scroll position as changed if it changed. */
+    rendered(): void;
+    /**
+     * Stores and reports the dirty parts now (normally called by the timer of {@link markDirty}).
+     */
+    flush(): void;
+    /** Stops the timer and stores / reports a pending change (called by `TableScope.destroy()`). */
+    destroy(): void;
+    private storageKey;
+    private storage;
+    /** The parts switched on in {@link AutoRestoreOptionsIf}. */
+    private persistedParts;
+    private warnWithoutStorageKey;
+    /** The stored state (or the one of the keys before 1.1.92) over `tableOptions.initialState`. */
+    private readStartState;
+    private persist;
+    private rememberAsReported;
+    private partJson;
+    private computePart;
+    private computeColumns;
+    private computeSort;
+    private computeScroll;
+    private computeTree;
+    private computeChecked;
+    private computeSelection;
+    /**
+     * A cell range → ids and properties. A range to the last row / column (`MAX_SAFE_INTEGER`) has no `toRowId` /
+     * `toProperty` ("to the end"); a range over all rows / columns has neither.
+     */
+    private toStateRange;
+    /** @returns true if a group changed */
+    private applyHeaderGroups;
+    /**
+     * Order, visibility and widths of the columns.
+     *
+     * @param {TableColumnStateIf[]} columns - the stored columns
+     * @param {boolean} resetMissingWidths - columns without width get the width of the code back (applyState)
+     * @returns true if the widths must be recalculated (a `%` or weight width came back)
+     */
+    private applyColumns;
+    private applyTree;
+    private applySort;
+    private applyChecked;
+    private applySelection;
+    private applyScroll;
+    private columnDefs;
+    private body;
+    private headerGroupModel;
+    /** Warn about rows without id only for parts that are stored (a `getState()` for an own use stays quiet). */
+    private warns;
+    /** The own `getRowId`, `undefined` for the default of {@link AutoRestoreOptions} (or none). */
+    private ownGetRowId;
+    /** The id of the displayed row at `index`. */
+    private idAt;
+    /**
+     * The id of a row (tree rows: of `row.data`): an own `getRowId`, otherwise the property `id` or `uuid`. Rows
+     * without id are not stored – the JSON fallback of the default `getRowId` would write whole rows (personal data)
+     * into the storage. Rows without an object get an id only from an own `getRowId` that declares the second
+     * parameter (`(_row, rowIndex) => rowIndex`).
+     */
+    private idOfRow;
+    /** id → displayed row index (one pass over the displayed rows). */
+    private rowIndexMap;
+    private walkTree;
+}