@revolist/revogrid 4.22.1 → 4.23.1

package/dist/revo-grid/viewport.helpers-CoCAvmZs.js

@@ -0,0 +1,133 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+const FALLBACK_MAX_SCROLL_SIZE = 16000000;
+const SCROLL_SIZE_GUARD = 1000000;
+let detectedMaxScrollSize;
+function getMaxScrollSize(doc = typeof document === 'undefined' ? undefined : document) {
+    if (typeof detectedMaxScrollSize === 'number') {
+        return detectedMaxScrollSize;
+    }
+    const body = doc === null || doc === void 0 ? void 0 : doc.body;
+    if (body) {
+        const ownerDocument = body.ownerDocument;
+        const element = ownerDocument.createElement('div');
+        element.style.cssText = [
+            'height:1px',
+            'left:-10000px',
+            'overflow:scroll',
+            'position:absolute',
+            'top:-10000px',
+            'visibility:hidden',
+            'width:1px',
+        ].join(';');
+        const content = ownerDocument.createElement('div');
+        content.style.height = `${FALLBACK_MAX_SCROLL_SIZE * 4}px`;
+        element.appendChild(content);
+        body.appendChild(element);
+        detectedMaxScrollSize = Math.max(0, Math.min(element.scrollHeight, FALLBACK_MAX_SCROLL_SIZE * 4) - SCROLL_SIZE_GUARD);
+        element.remove();
+        if (detectedMaxScrollSize > SCROLL_SIZE_GUARD) {
+            return detectedMaxScrollSize;
+        }
+        detectedMaxScrollSize = FALLBACK_MAX_SCROLL_SIZE;
+        return detectedMaxScrollSize;
+    }
+    return FALLBACK_MAX_SCROLL_SIZE;
+}
+function getScrollDimension({ contentSize, clientSize, virtualSize = 0, maxScrollSize = getMaxScrollSize(), }) {
+    const safeContentSize = Math.max(0, maxScrollSize - SCROLL_SIZE_GUARD);
+    const size = Math.max(0, contentSize);
+    const client = Math.max(0, clientSize);
+    const viewport = Math.max(0, virtualSize || client);
+    const logicalScrollSize = Math.max(0, size - viewport);
+    const maxPhysicalScrollSize = Math.max(0, safeContentSize - client);
+    const physicalScrollSize = Math.min(logicalScrollSize, maxPhysicalScrollSize);
+    const physicalContentSize = client + physicalScrollSize;
+    const isCompressed = logicalScrollSize > physicalScrollSize && physicalScrollSize > 0;
+    const clampLogical = (coordinate) => Math.min(Math.max(0, coordinate || 0), logicalScrollSize);
+    const clampPhysical = (coordinate) => Math.min(Math.max(0, coordinate || 0), physicalScrollSize);
+    const toLogicalCoordinate = (coordinate) => {
+        if (!logicalScrollSize || !physicalScrollSize) {
+            return 0;
+        }
+        if (!isCompressed) {
+            return clampLogical(coordinate);
+        }
+        return clampLogical((clampPhysical(coordinate) / physicalScrollSize) * logicalScrollSize);
+    };
+    const toPhysicalCoordinate = (coordinate) => {
+        if (!logicalScrollSize || !physicalScrollSize) {
+            return 0;
+        }
+        if (!isCompressed) {
+            return clampPhysical(coordinate);
+        }
+        return clampPhysical((clampLogical(coordinate) / logicalScrollSize) * physicalScrollSize);
+    };
+    return {
+        contentSize: size,
+        clientSize: client,
+        viewportSize: viewport,
+        physicalContentSize,
+        logicalScrollSize,
+        physicalScrollSize,
+        isCompressed,
+        toLogicalCoordinate,
+        toPhysicalCoordinate,
+        getRenderOffset(coordinate) {
+            const logical = clampLogical(coordinate);
+            return logical - toPhysicalCoordinate(logical);
+        },
+    };
+}
+
+/**
+ * Collects data for pinned columns in the required @ViewportProps format.
+ */
+/**
+ * Represents the slot names for the viewport slots.
+ */
+const HEADER_SLOT = 'header'; // Slot name for the header slot
+const FOOTER_SLOT = 'footer'; // Slot name for the footer slot
+const CONTENT_SLOT = 'content'; // Slot name for the content slot
+const DATA_SLOT = 'data'; // Slot name for the data slot
+/**
+ * Returns the last visible cell in the viewport for a given row type.
+ * Coordinates are not zero-based and are relative to the viewport.
+ * If needed to be zero-based they can be adjusted by subtracting 1.
+ */
+function getLastCell(data, rowType) {
+    // Get the last visible column count from the viewport column data.
+    const lastVisibleColumnCount = data.viewports[data.colType].store.get('realCount');
+    // Get the last visible row count for the given row type from the viewport column data.
+    const lastVisibleRowCount = data.viewports[rowType].store.get('realCount');
+    // Return the last visible cell with the last visible column count and row count.
+    return {
+        x: lastVisibleColumnCount,
+        y: lastVisibleRowCount,
+    };
+}
+function viewportDataPartition(data, type, slot, fixed) {
+    return {
+        colData: data.colStore,
+        viewportCol: data.viewports[data.colType].store,
+        viewportRow: data.viewports[type].store,
+        /**
+         * lastCell is the last real coordinate + 1, saved to selection store
+         */
+        lastCell: getLastCell(data, type),
+        slot,
+        type,
+        canDrag: !fixed,
+        position: data.position,
+        dataStore: data.rowStores[type].store,
+        dimensionCol: data.dimensions[data.colType].store,
+        dimensionRow: data.dimensions[type].store,
+        style: fixed
+            ? { height: `${data.dimensions[type].store.get('realSize')}px` }
+            : undefined,
+    };
+}
+
+export { CONTENT_SLOT as C, DATA_SLOT as D, FOOTER_SLOT as F, HEADER_SLOT as H, getScrollDimension as g, viewportDataPartition as v };

package/dist/{esm/viewport.store-CFjDW-3l.js → revo-grid/viewport.store-COAfzAyu.js}

@@ -1,7 +1,7 @@
 /*!
  * Built by Revolist OU ❤️
  */
-import { j as getItemByPosition, W as createStore, w as setStore } from './dimension.helpers-DmIvjIa7.js';
+import { j as getItemByPosition, K as createStore, l as setStore } from './dimension.helpers-CGKwSvw6.js';
 
 const LETTER_BLOCK_SIZE = 10;
 const calculateRowHeaderSize = (itemsLength, rowHeaderColumn, minWidth = 50) => {
@@ -9,6 +9,15 @@ const calculateRowHeaderSize = (itemsLength, rowHeaderColumn, minWidth = 50) =>
         Math.max((itemsLength.toString().length + 1) * LETTER_BLOCK_SIZE, minWidth));
 };
 
+function getViewportMaxCoordinate(dimension, viewportSize, frameOffset = 1) {
+    if (!viewportSize || dimension.realSize <= viewportSize) {
+        return 0;
+    }
+    return Math.max(0, dimension.realSize - viewportSize - dimension.originItemSize * frameOffset);
+}
+function clampViewportCoordinate(coordinate, dimension, viewportSize, frameOffset = 1) {
+    return Math.min(Math.max(0, coordinate), getViewportMaxCoordinate(dimension, viewportSize, frameOffset));
+}
 /**
  * Update items based on new scroll position
  * If viewport wasn't changed fully simple recombination of positions
@@ -274,6 +283,8 @@ function initialState() {
         realCount: 0,
         // size of viewport in px
         clientSize: 0,
+        // logical-to-physical render offset used when scroll space is compressed
+        renderOffset: 0,
     };
 }
 /**
@@ -309,21 +320,8 @@ class ViewportStore {
         const outsize = singleOffsetInPx * 2;
         // math virtual size is based on visible area + 2 items outside of visible area
         const virtualSize = viewportSize + outsize;
-        // expected no scroll if real size less than virtual size, position is 0
-        let maxCoordinate = 0;
-        // if there is nodes outside of viewport, max coordinate has to be adjusted
-        if (dimension.realSize > viewportSize) {
-            // max coordinate is real size minus virtual/rendered space
-            maxCoordinate = dimension.realSize - viewportSize - singleOffsetInPx;
-        }
-        let pos = position;
-        // limit position to max and min coordinates
-        if (pos < 0) {
-            pos = 0;
-        }
-        else if (pos > maxCoordinate) {
-            pos = maxCoordinate;
-        }
+        const maxCoordinate = getViewportMaxCoordinate(dimension, viewportSize, frameOffset);
+        let pos = clampViewportCoordinate(position, dimension, viewportSize, frameOffset);
         // store last coordinate for further restore on redraw
         this.lastCoordinate = pos;
         // actual position is less than first item start based on offset
@@ -401,4 +399,4 @@ class ViewportStore {
     }
 }
 
-export { ViewportStore as V, addMissingItems as a, getItems as b, isActiveRangeOutsideLastItem as c, getFirstItem as d, getLastItem as e, calculateRowHeaderSize as f, getUpdatedItemsByPosition as g, isActiveRange as i, recombineByOffset as r, setItemSizes as s, updateMissingAndRange as u };
+export { ViewportStore as V, getUpdatedItemsByPosition as a, addMissingItems as b, clampViewportCoordinate as c, getItems as d, isActiveRangeOutsideLastItem as e, getFirstItem as f, getViewportMaxCoordinate as g, getLastItem as h, isActiveRange as i, calculateRowHeaderSize as j, recombineByOffset as r, setItemSizes as s, updateMissingAndRange as u };

package/dist/types/components/header/header-group-renderer.d.ts

@@ -3,12 +3,14 @@ import { Group } from "../../store/index";
 import type { ProvidersColumns } from "../../types/index";
 import { ResizeEvent, ResizeProps } from './resizable.directive';
 export type HeaderGroupRendererProps = {
+    level: number;
     start: number;
     end: number;
     group: Group;
     providers: ProvidersColumns;
     additionalData: any;
     canResize?: boolean;
+    renderOffset?: number;
     onResize?(e: ResizeEvent): void;
 } & Partial<Pick<ResizeProps, 'active'>>;
 declare const HeaderGroupRenderer: (p: HeaderGroupRendererProps) => ReturnType<typeof h>;

package/dist/types/components/header/header-renderer.d.ts

@@ -8,6 +8,7 @@ export type HeaderRenderProps = {
     range?: RangeArea | null;
     canResize?: boolean;
     canFilter?: boolean;
+    renderOffset?: number;
     onResize?(e: ResizeEvent): void;
     onClick?(data: InitialHeaderClick): void;
     onDblClick?(data: InitialHeaderClick): void;

package/dist/types/components/header/revogr-header.d.ts

@@ -88,6 +88,8 @@ export declare class RevogrHeaderComponent {
     private renderGroupingColumns;
     private renderGroupRow;
     private renderGroupColumn;
+    private getGroupIndexRange;
+    private getGroupBounds;
     private getVisibleGroupRange;
     private getHeaderCellKey;
     private getDuplicateHeaderProps;

package/dist/types/components/overlay/keyboard.service.d.ts

@@ -15,6 +15,11 @@ type Config = {
 export declare class KeyboardService {
     private sv;
     constructor(sv: Config);
+    /**
+     * Appends printable key input that arrives after edit mode was requested
+     * but before the editor input has mounted or received focus.
+     */
+    private appendPendingEditValue;
     keyDown(e: KeyboardEvent, canRange: boolean, isEditMode: boolean, { range, focus }: Nullable<Pick<EventData, 'range' | 'focus'>>): Promise<void>;
     private selectAll;
     keyChangeSelection(e: KeyboardEvent, canRange: boolean): Promise<boolean>;

package/dist/types/components/revoGrid/revo-grid.d.ts

@@ -626,8 +626,20 @@ export declare class RevoGridComponent {
     orderService: OrdererService;
     selectionStoreConnector?: SelectionStoreConnector;
     scrollingService: GridScrollingService;
+    private pendingColumnFocusRestore?;
     columnTypesChanged(): void;
     columnChanged(newVal?: (ColumnGrouping | ColumnRegular)[], _prevVal?: (ColumnGrouping | ColumnRegular)[] | undefined, __watchName?: string, init?: boolean): void;
+    /**
+     * Capture logical focus before columns are repartitioned by pin state.
+     * Regression case: selecting a regular cell, then pinning that column left,
+     * used to let the new pinned viewport reuse the old rgCol selection store.
+     */
+    private getColumnFocusRestore;
+    /**
+     * Reapply focus by column prop after render, once pinning has moved the
+     * column to its new viewport and virtual index.
+     */
+    private restoreColumnFocusAfterRender;
     disableVirtualXChanged(newVal?: boolean, prevVal?: boolean): void;
     rowSizeChanged(s: number): void;
     themeChanged(t: Theme, _?: Theme, __?: string, init?: boolean): void;

package/dist/types/plugins/groupingRow/grouping.row.plugin.d.ts

@@ -20,6 +20,14 @@ export declare class GroupingRowPlugin extends BasePlugin {
     private beforeTrimmedApply;
     private beforeFilterTrimmed;
     private isSortingRunning;
+    /**
+     * Returns grouping options for regrouping that must preserve current UI state.
+     *
+     * `expandedAll` and config `prevExpanded` are initial/config instructions.
+     * Reusing them after sorting would reopen groups the user collapsed before
+     * sorting instead of using the current grouped source state.
+     */
+    private getCurrentExpandedOptions;
     /**
      * Starts global source update with group clearing and applying new one
      * Initiated when need to reapply grouping

package/dist/types/plugins/sorting/sorting.func.d.ts

@@ -1,6 +1,29 @@
 import type { CellCompareFunc, ColumnProp, ColumnRegular, DataType, Order } from "../../types/index";
-import type { SortingOrderFunction } from './sorting.types';
-export declare function sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction): number[];
+import type { SortingColumnMap, SortingColumnOrder, SortingColumnRender, SortingOrder, SortingOrderFunction } from './sorting.types';
+/**
+ * Checks whether a sorting map contains at least one active order.
+ *
+ * Empty maps and properties with `undefined` order are treated as inactive.
+ */
+export declare function hasActiveSorting(sorting?: SortingOrder): boolean;
+/**
+ * Returns one-based additive sorting rank for a column.
+ *
+ * A single active sort does not need a visible rank, so it returns undefined.
+ */
+export declare function getSortingIndex(sorting: SortingOrder | undefined, prop: ColumnProp, sortingOrder?: SortingColumnOrder): SortingColumnRender['sortIndex'];
+/**
+ * Sorts row indexes against a source collection.
+ *
+ * @param indexes - Current proxy row indexes to sort.
+ * @param source - Full source collection addressed by the indexes.
+ * @param sortingFunc - Comparator functions by column property.
+ * @param sorting - Active sorting order by column property.
+ * @param sortingColumns - Column metadata by property for default-comparer optimization.
+ * @param sortingOrder - Active sorting priority in click/config insertion order.
+ * @returns Sorted proxy indexes. With no sorting function keys, returns source-order indexes.
+ */
+export declare function sortIndexByItems(indexes: number[], source: DataType[], sortingFunc?: SortingOrderFunction, sorting?: SortingOrder, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder): number[];
 export declare function defaultCellCompare(this: {
     column?: ColumnRegular;
 }, prop: ColumnProp, a: DataType, b: DataType): 0 | 1 | -1;

package/dist/types/plugins/sorting/sorting.plugin.d.ts

@@ -1,6 +1,6 @@
 import { BasePlugin } from '../base.plugin';
 import type { ColumnRegular, DimensionRows, PluginProviders } from "../../types/index";
-import type { SortingConfig, SortingOrder, SortingOrderFunction } from './sorting.types';
+import type { SortingColumnMap, SortingColumnOrder, SortingConfig, SortingOrder, SortingOrderFunction } from './sorting.types';
 export * from './sorting.types';
 export * from './sorting.func';
 export * from './sorting.sign';
@@ -15,34 +15,109 @@ export * from './sorting.sign';
  */
 export declare class SortingPlugin extends BasePlugin {
     revogrid: HTMLRevoGridElement;
+    /**
+     * Current sorting order per column property.
+     */
     sorting?: SortingOrder;
+    /**
+     * Comparator functions indexed by column property.
+     *
+     * Multiple columns can be sorted at the same time.
+     */
     sortingFunc?: SortingOrderFunction;
     /**
-     * Delayed sorting promise
+     * Column metadata for the current sorting state.
+     *
+     * Used internally to optimize default sorting without changing comparator
+     * functions or their public API contract.
+     */
+    private sortingColumns?;
+    /**
+     * Active sorting priority in click/config insertion order.
+     *
+     * Required for numeric column props because object key iteration does not
+     * preserve insertion order for integer-like keys.
+     */
+    private sortingOrder?;
+    /**
+     * Delayed sorting promise registered in the grid render job queue.
      */
     sortingPromise: (() => void) | null;
     /**
-     * We need to sort only so often
+     * Debounced sorting entry point.
+     *
+     * Sorting can be requested by column changes, source changes, and header
+     * clicks in quick succession, so the actual sort is delayed and coalesced.
      */
-    postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean) => void>;
+    postponeSort: import("lodash").DebouncedFunc<(order?: SortingOrder, comparison?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, ignoreViewportUpdate?: boolean) => void>;
     constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: SortingConfig);
     /**
-     * Entry point for sorting, waits for all delays, registers jobs
+     * Creates mutable sorting maps from current state when additive sorting is requested.
+     */
+    private createSortingState;
+    /**
+     * Stores normalized sorting state, clearing inactive empty maps.
+     */
+    private setSortingState;
+    /**
+     * Adds or replaces a column in a sorting state.
+     */
+    private setColumnSorting;
+    /**
+     * Removes a column from a sorting state.
+     */
+    private clearColumnSorting;
+    /**
+     * Normalizes external sorting configuration into internal order,
+     * comparator, and column metadata maps.
+     */
+    private applySortingConfig;
+    /**
+     * Schedules sorting before the next render.
+     *
+     * @param order - Active sorting order by column property.
+     * @param sortingFunc - Comparator functions by column property.
+     * @param sortingColumns - Column metadata by property.
+     * @param sortingOrder - Active sorting priority in click/config insertion order.
+     * @param ignoreViewportUpdate - Skips dimension position recalculation when true.
      */
     startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    startSorting(order?: SortingOrder, sortingFunc?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, ignoreViewportUpdate?: boolean): void;
     /**
-     * Apply sorting to data on header click
-     * If additive - add to existing sorting, multiple columns can be sorted
+     * Applies sorting requested by a sortable header click.
+     *
+     * @param column - Column that initiated sorting.
+     * @param additive - If true, add/remove this column from the current multi-sort state.
      */
     headerclick(column: ColumnRegular, additive: boolean): void;
+    /**
+     * Applies sorting state produced by a header click.
+     */
+    private applyHeaderSorting;
+    /**
+     * Runs a scheduled sort and resolves the render-blocking sorting promise.
+     *
+     * @param order - Active sorting order by column property.
+     * @param comparison - Comparator functions by column property.
+     * @param sortingColumns - Column metadata by property.
+     * @param sortingOrder - Active sorting priority in click/config insertion order.
+     * @param ignoreViewportUpdate - Skips dimension position recalculation when true.
+     */
     runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, ignoreViewportUpdate?: boolean): void;
+    runSorting(order?: SortingOrder, comparison?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, ignoreViewportUpdate?: boolean): void;
     /**
-     * Sort items by sorting function
+     * Sorts row proxy indexes by sorting functions.
+     *
      * @requires proxyItems applied to row store
      * @requires source applied to row store
      *
      * @param sorting - per column sorting
-     * @param data - this.stores['rgRow'].store.get('source')
+     * @param sortingFunc - Comparator functions by column property.
+     * @param sortingColumns - Column metadata by property.
+     * @param sortingOrder - Active sorting priority in click/config insertion order.
+     * @param types - Row stores to sort.
+     * @param ignoreViewportUpdate - Skips dimension position recalculation when true.
      */
     sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, types?: DimensionRows[], ignoreViewportUpdate?: boolean): void;
+    sort(sorting?: SortingOrder, sortingFunc?: SortingOrderFunction, sortingColumns?: SortingColumnMap, sortingOrder?: SortingColumnOrder, types?: DimensionRows[], ignoreViewportUpdate?: boolean): void;
 }

package/dist/types/plugins/sorting/sorting.sign.d.ts

@@ -1,6 +1,10 @@
 import { ColumnRegular } from "../../types/index";
+import type { SortingColumnRender } from './sorting.types';
 type Props = {
-    column: ColumnRegular;
+    column: ColumnRegular & SortingColumnRender;
 };
+/**
+ * Renders sorting direction and optional additive sorting rank.
+ */
 export declare const SortingSign: ({ column }: Props) => any;
 export {};

package/dist/types/plugins/sorting/sorting.types.d.ts

@@ -1,14 +1,59 @@
-import type { CellCompareFunc, ColumnProp, Order } from "../../types/index";
+import type { CellCompareFunc, ColumnProp, ColumnRegular, Order } from "../../types/index";
+/**
+ * Current sorting order per column property.
+ */
 export type SortingOrder = Record<ColumnProp, Order>;
+/**
+ * Comparator functions indexed by column property.
+ *
+ * Undefined comparator entries are treated as inactive sorting entries.
+ */
 export type SortingOrderFunction = Record<ColumnProp, CellCompareFunc | undefined>;
+/**
+ * Column metadata indexed by column property.
+ *
+ * This is an internal companion map for `SortingOrderFunction`. It lets the
+ * sorting helper detect the default comparer path without mutating
+ * `CellCompareFunc` instances or changing the public comparator contract.
+ */
+export type SortingColumnMap = Record<ColumnProp, Partial<ColumnRegular> | undefined>;
+/**
+ * Active sorting priority in click/config insertion order.
+ *
+ * This is stored separately from `SortingOrder` because JavaScript object keys
+ * that look like integers are enumerated in numeric order, not insertion order.
+ */
+export type SortingColumnOrder = ColumnProp[];
+/**
+ * Header metadata used to display additive sort priority.
+ */
+export type SortingColumnRender = {
+    /**
+     * One-based additive sorting rank.
+     */
+    sortIndex?: number;
+};
+/**
+ * Sorting information emitted after columns are set.
+ */
 export type ColumnSetEvent = {
     order: SortingOrder;
 };
+/**
+ * External sorting configuration.
+ */
 export type SortingConfig = {
+    /**
+     * Columns to sort by.
+     */
     columns?: {
         prop: ColumnProp;
         order: Order;
         cellCompare?: CellCompareFunc;
     }[];
+    /**
+     * If true, merge provided columns with the current sorting state.
+     * If false or omitted, replace current sorting state.
+     */
     additive?: boolean;
 };

package/dist/types/services/local.scroll.service.d.ts

@@ -1,4 +1,5 @@
 import type { DimensionType, ViewPortScrollEvent } from "../types/index";
+import { type ScrollDimension } from './scroll.dimension.helpers';
 interface Config {
     skipAnimationFrame?: boolean;
     runScroll(e: ViewPortScrollEvent): void;
@@ -10,6 +11,8 @@ type Params = {
     clientSize: number;
     virtualSize: number;
     maxSize?: number;
+    maxScrollSize?: number;
+    scrollDimension?: ScrollDimension;
 };
 /**
  * Based on content size, client size and virtual size
@@ -20,17 +23,22 @@ export default class LocalScrollService {
     private cfg;
     private preventArtificialScroll;
     private previousScroll;
+    private previousLogicalScroll;
     private params;
     constructor(cfg: Config);
     setParams(params: Params, dimension: DimensionType): void;
     setScroll(e: ViewPortScrollEvent): Promise<void>;
+    setScrollByDelta(e: ViewPortScrollEvent, currentPhysicalCoordinate: number): Promise<ViewPortScrollEvent>;
     /**
      * On scroll event started
      */
     scroll(coordinate: number, dimension: DimensionType, force?: boolean, delta?: number, outside?: boolean): void;
     private getParams;
-    private wrapCoordinate;
+    private wrapPhysicalCoordinate;
+    private wrapLogicalCoordinate;
     private cancelScroll;
-    private convert;
+    private toLogicalScrollCoordinate;
+    private toPhysicalCoordinate;
+    private toLogicalCoordinate;
 }
 export {};

package/dist/types/services/scroll.dimension.helpers.d.ts

@@ -0,0 +1,20 @@
+export type ScrollDimensionInput = {
+    contentSize: number;
+    clientSize: number;
+    virtualSize?: number;
+    maxScrollSize?: number;
+};
+export type ScrollDimension = {
+    contentSize: number;
+    clientSize: number;
+    viewportSize: number;
+    physicalContentSize: number;
+    logicalScrollSize: number;
+    physicalScrollSize: number;
+    isCompressed: boolean;
+    toLogicalCoordinate(coordinate: number): number;
+    toPhysicalCoordinate(coordinate: number): number;
+    getRenderOffset(coordinate: number): number;
+};
+export declare function getMaxScrollSize(doc?: Document | undefined): number;
+export declare function getScrollDimension({ contentSize, clientSize, virtualSize, maxScrollSize, }: ScrollDimensionInput): ScrollDimension;

package/dist/types/services/selection.store.connector.d.ts

@@ -70,5 +70,11 @@ export declare class SelectionStoreConnector {
     selectAll(): void;
     private getXStores;
     private getYStores;
+    /**
+     * Keep column viewport positions and types in sync across pin/unpin rerenders.
+     * Regression case: when a selected rgCol cell was pinned left, colPinStart
+     * could take over x=0 and render the stale rgCol focus store in the pinned area.
+     */
+    private updateColumnTypeMapping;
 }
 export {};

package/dist/types/store/vp/viewport.helpers.d.ts

@@ -1,6 +1,8 @@
 import type { DimensionSettingsState, PositionItem, ViewSettingSizeProp, ViewportStateItems, VirtualPositionItem, Range } from "../../types/index";
 export type DimensionDataViewport = Pick<DimensionSettingsState, 'indexes' | 'positionIndexes' | 'positionIndexToItem' | 'sizes' | 'originItemSize' | 'realSize'>;
 export type ItemsToUpdate = Pick<ViewportStateItems, 'items' | 'start' | 'end'>;
+export declare function getViewportMaxCoordinate(dimension: Pick<DimensionSettingsState, 'realSize' | 'originItemSize'>, viewportSize: number, frameOffset?: number): number;
+export declare function clampViewportCoordinate(coordinate: number, dimension: Pick<DimensionSettingsState, 'realSize' | 'originItemSize'>, viewportSize: number, frameOffset?: number): number;
 /**
  * Update items based on new scroll position
  * If viewport wasn't changed fully simple recombination of positions

package/dist/types/types/interfaces.d.ts

@@ -509,6 +509,12 @@ export interface ViewportState extends ViewportStateItems {
      * Until virtualization is not disabled.
      */
     clientSize: number;
+    /**
+     * Difference between logical coordinate and browser-safe rendered coordinate.
+     * Internal scroll virtualization offset used when content exceeds browser
+     * native scroll size limits.
+     */
+    renderOffset?: number;
 }
 /**
  * `ViewSettingSizeProp` is a record that maps column or row indexes to their
@@ -625,6 +631,11 @@ export interface DimensionSettingsState extends DimensionCalc {
      * Represents the origin item size of the dimension.
      */
     originItemSize: number;
+    /**
+     * Internal render offset applied when logical scroll space is compressed into
+     * a browser-safe physical scroll range.
+     */
+    renderOffset?: number;
 }
 /**
  * Represents the mapping of dimension types to their corresponding observable stores.

package/dist/types/types/selection.d.ts

@@ -65,6 +65,19 @@ export type ChangedRange = {
         [newRowIndex: number]: DataType;
     };
 };
+/**
+ * Logical focus marker captured before column viewport ownership changes.
+ * Used when a selected column is pinned/unpinned so focus can be restored by
+ * column prop after the column moves between rgCol, colPinStart, or colPinEnd.
+ */
+export type PendingColumnFocusRestore = {
+    prop: ColumnProp;
+    colType: DimensionCols;
+    colIndex: ColIndex;
+    prevStoreX: ColIndex;
+    rowType: DimensionRows;
+    rowIndex: RowIndex;
+};
 /**
  * Cell coordinates
  */