@daisforge/ui 1.10.3

package/components/TableContract/lib/getRowKeyGetter.d.ts

@@ -0,0 +1,3 @@
+import { ObjectAny } from '../types.contractResponse';
+
+export declare const getRowKeyGetter: (rowUniqIdKey: string) => (row: ObjectAny) => string;

package/components/TableContract/lib/number.d.ts

@@ -0,0 +1 @@
+export declare function getNum(value: string | number | null): number | null;

package/components/TableContract/lib/recursiveGetV.d.ts

@@ -0,0 +1,3 @@
+import { ObjectAny } from '../types.contractResponse';
+
+export declare const recursGetV: (r: ObjectAny, keysR: string[]) => unknown;

package/components/TableContract/params.d.ts

@@ -0,0 +1,3 @@
+import { UrlAction } from './types';
+
+export declare function paramsReducer(state: URLSearchParams, action: UrlAction): URLSearchParams;

package/components/TableContract/responseMapper.d.ts

@@ -0,0 +1,12 @@
+import { ContractColumnConfig, ContractResponse, ContractTableConfig, InstanceColumnConfig, ObjectAny } from './types';
+import { DataType } from './constants';
+
+export declare const ANSI_SQL_TO_UI_EDITING: Record<DataType['ansiSqlType'], NonNullable<InstanceColumnConfig['editingCell']>>;
+export declare const columnsConfigMapper: (columnsConfigBackend: ContractColumnConfig[], tableConfigBackend: ContractTableConfig | undefined) => InstanceColumnConfig[];
+export declare const responseMapper: (resp: ContractResponse) => {
+    rows: ObjectAny[];
+    columnsConfig: InstanceColumnConfig[];
+    tableConfigBackend: ContractTableConfig | undefined;
+    topSummaryRows: ObjectAny[] | undefined;
+    bottomSummaryRows: ObjectAny[] | undefined;
+};

package/components/TableContract/types.contractQueryParams.d.ts

@@ -0,0 +1,13 @@
+import { Q_PARAMS } from './constants';
+
+export type ContractQueryParams = {
+    [Q_PARAMS.sort]?: string | null;
+    [Q_PARAMS.page]?: string | null;
+    [Q_PARAMS.pageSize]?: string | null;
+    [Q_PARAMS.q]?: string | null;
+};
+export type ParamKey = keyof typeof Q_PARAMS;
+export type PaginationParams = {
+    [Q_PARAMS.page]?: number;
+    [Q_PARAMS.pageSize]?: number;
+};

package/components/TableContract/types.contractResponse.d.ts

@@ -0,0 +1,147 @@
+import { ColumnAnsiSqlType } from './constants';
+
+export type ObjectAny = Record<string, any>;
+type ContractColumnEditingCell = {
+    error?: {
+        value: {
+            keyInRow: string;
+            errorValue: string;
+        };
+    };
+    editable?: {
+        keyInRow: string;
+        editableValue: string;
+    };
+} & ({
+    component: 'inputString';
+} | {
+    component: 'inputNumber';
+} | {
+    component: 'select';
+    options: {
+        type: 'constant';
+        options: {
+            value: string | number;
+            text: string | number;
+        }[];
+    };
+});
+export type ContractColumnConfig = {
+    key: string;
+    name: string | number;
+    columnType?: ColumnAnsiSqlType;
+    title?: string;
+    sortingType?: 'stringSort' | 'numberSort';
+    searching?: {
+        keyInRow: string;
+    };
+    contentFormat?: number | {
+        alignContent?: 'right' | 'left' | 'center';
+    } | {
+        type: 'number';
+        decimalSeparator?: string;
+        thousandSeparator?: string;
+        minimumFractionDigits?: number;
+        maximumFractionDigits?: number;
+        useGrouping?: boolean;
+        locales?: string | string[];
+        alignContent?: 'right' | 'left' | 'center';
+    };
+    subRow?: {
+        keyOfColumnInSubRow?: string | number | Record<number | 'default', string>;
+        isColumnWithArrow?: boolean;
+        hideHeaderExpandAllArrow?: boolean;
+        parentKeyAsDefault?: boolean;
+        contentFormat?: number | {
+            alignContent?: 'right' | 'left' | 'center';
+        } | {
+            type: 'number';
+            decimalSeparator?: string;
+            thousandSeparator?: string;
+            minimumFractionDigits?: number;
+            maximumFractionDigits?: number;
+            useGrouping?: boolean;
+            locales?: string | string[];
+            alignContent?: 'right' | 'left' | 'center';
+        };
+        editingCell?: ContractColumnEditingCell;
+    };
+    editingCell?: ContractColumnEditingCell;
+    resizable?: boolean;
+    summaryCell?: {
+        key?: string;
+        text?: string;
+    };
+    width?: number | string;
+    minWidth?: number;
+    maxWidth?: number;
+};
+export type ContractTableConfig = {
+    sorting?: {
+        type: 'frontend' | 'backend';
+    };
+    pagination?: {
+        total: number;
+        totalRows: number;
+        defaultPage: number;
+        defaultPageSize: number;
+        page: number;
+        pageSize: number;
+        pageSizeList?: number[];
+    };
+    editing?: {
+        saving: {
+            type: 'onSubmit' | 'onRowChange';
+        };
+        rowUniqIdKey: string;
+        rowEditable?: {
+            keyInRow: string;
+            editableValue: string;
+        };
+        defaultEnabled?: boolean;
+        showToggleEnabledButton?: boolean;
+    };
+    subRows?: {
+        subRowsKey: string;
+        rowUniqIdKey: string;
+    };
+    filtering?: {
+        type: 'backend';
+    };
+    searching?: {
+        enabled: boolean;
+        type: 'frontend' | 'backend';
+        defaultSearchQuery?: string;
+        showSearchBlock?: boolean;
+        debounceDelay?: number;
+        isDebounceActive?: boolean;
+        placeholder?: string;
+        searchClasses?: string;
+    };
+    height?: string;
+    fullScreenEnabled?: boolean;
+    summaryRows?: {
+        showDefault: boolean;
+        showInControl: boolean;
+    };
+    resizableColumn?: boolean;
+    rowSize?: {
+        showInControl: boolean;
+        default?: 'small' | 'medium' | 'big';
+        available?: ('small' | 'medium' | 'big')[];
+    };
+    rowHeight?: number;
+    containerStyle?: ObjectAny;
+};
+export type ContractResponse = {
+    data: {
+        main: ObjectAny[];
+        topSummary?: ObjectAny[];
+        bottomSummary?: ObjectAny[];
+    };
+    meta: {
+        columns: ContractColumnConfig[];
+        tableConfig?: ContractTableConfig;
+    };
+};
+export {};

package/components/TableContract/types.d.ts

@@ -0,0 +1,18 @@
+import { ContractColumnConfig } from './types.contractResponse';
+import { PaginationParams } from './types.contractQueryParams';
+import { ColumnConfig, ControlBlockButtonProps, ObjectForExtending, SortColumn, TableConfig, TableProps } from '../Table';
+
+export type * from './types.contractQueryParams';
+export type * from './types.contractResponse';
+export { ControlBlockButtonProps as TableContractControlBlockButtonProps };
+export type InstanceTableProps = TableProps<ObjectForExtending, string, ObjectForExtending, ObjectForExtending, ObjectForExtending, ObjectForExtending>;
+export type InstanceColumnConfig = ColumnConfig<ObjectForExtending> & Pick<ContractColumnConfig, 'columnType'>;
+export type InstanceTableConfig = TableConfig<ObjectForExtending, unknown, string, ObjectForExtending>;
+export type UrlAction = [param: 'sortKey', payload: readonly SortColumn[]] | [param: 'pagination', payload: PaginationParams] | [param: 'q', payload: string] | [param: 'filters', payload: Record<string, string>];
+export type FetcherProps = {
+    pathParams?: string;
+    params?: string;
+    method?: RequestInit['method'];
+    body?: RequestInit['body'];
+};
+export type FetcherFunc = (p: FetcherProps) => Promise<Response>;

package/components/TableContract/ui/AddRowsIconButtonWithPopover.d.ts

@@ -0,0 +1,3 @@
+export declare const AddRowsIconButtonWithPopover: ({ onSubmit }: {
+    onSubmit: (countOfAddedRow: number) => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/components/TableContract/ui/selectBooleanEditor.d.ts

@@ -0,0 +1,4 @@
+import { RenderEditCellProps } from 'react-data-grid';
+import { ObjectForExtending } from '../../Table';
+
+export declare function SelectBooleanEditor<TRow extends ObjectForExtending, TSummaryRow>({ row, column, onRowChange }: RenderEditCellProps<TRow, TSummaryRow> & {}): import("react/jsx-runtime").JSX.Element;

package/components/TableGlide/TableGlide.d.ts

@@ -0,0 +1,9 @@
+import { ObjectForExtending, TableGlideProps } from './types';
+import { GridCell } from '@glideappsfinal/glide-data-grid';
+
+export declare class CellContentCache {
+    private cachedContent;
+    get(col: number, row: number): import('@glideappsfinal/glide-data-grid').TextCell | import('@glideappsfinal/glide-data-grid').ImageCell | import('@glideappsfinal/glide-data-grid').BooleanCell | import('@glideappsfinal/glide-data-grid').MarkdownCell | import('@glideappsfinal/glide-data-grid').UriCell | import('@glideappsfinal/glide-data-grid').NumberCell | import('@glideappsfinal/glide-data-grid').CustomCell<{}> | import('@glideappsfinal/glide-data-grid').BubbleCell | import('@glideappsfinal/glide-data-grid').RowIDCell | import('@glideappsfinal/glide-data-grid').LoadingCell | import('@glideappsfinal/glide-data-grid').ProtectedCell | import('@glideappsfinal/glide-data-grid').DrilldownCell | undefined;
+    set(colInd: number, rowInd: number, value: GridCell): void;
+}
+export declare const TableGlide: <R extends ObjectForExtending, SR = unknown>({ columns, rows, bottomSummaryRows, rowHeight, width, rowSize, ctxs, freezeColumns, onColumnResize, renderGroupHeader, refTable, onColumnsReorder, portalEventTargetRef, onItemHovered: onItemHoveredExternal, unstickyHeader, resizableColumn, minColumnWidth, maxColumnWidth, maxColumnAutoWidth, containerRef: containerRefExternal, containerClassName, containerStyle, renderOverlayFeatures, hideGrid, contentStateNode, fullScreened, editorOverlayPortal, highlightActiveType, cellsSelectionMode, enableColumnSelection, enableRowSelection, enableSelectAll, enableLowDprHairline, gridSelection: gridSelectionExternal, onGridSelectionChange: onGridSelectionChangeExternal, onSelectionEmit, onColumnSelectionChange, pendingColumnSelectionKeys, onColumnSelectionApplied, highlightActiveRow, onHighlightActiveRowChange, highlightActiveRowControlled, highlightRegions: highlightRegionsExternal, checkboxSelectedRowIndexes, checkboxVisibleRowIndexes, hoverEffects, onCellClicked: onCellClickedExternal, onCellContextMenu: onCellContextMenuExternal, onMouseMove: onMouseMoveExternal, portalElementRef: _portalElementRef, ...restProps }: TableGlideProps<R, SR>) => import("react/jsx-runtime").JSX.Element;

package/components/TableGlide/cellRenderer.d.ts

@@ -0,0 +1,20 @@
+import { CellContent, CellInfo, ObjectForExtending } from './types';
+import { CellCanvasRoot } from './lib/canvas';
+
+type CanvasCacheKey = string | number | boolean | null;
+interface CanvasCellCacheEntry {
+    cacheKey: CanvasCacheKey;
+    canvasRoot: CellCanvasRoot;
+}
+export declare const glideCellRenderer: <R extends ObjectForExtending, SR>({ jsxElement, canvasCellCache, cellInfo, options, }: {
+    jsxElement: CellContent;
+    cellInfo: CellInfo<R, SR>;
+    canvasCellCache: WeakMap<ObjectForExtending, Map<string, CanvasCellCacheEntry>>;
+    options: {
+        span?: readonly [number, number] | undefined;
+        data: string | undefined;
+        getPortalEventTarget?: () => EventTarget | null;
+        refTable?: unknown;
+    };
+}) => import('@glideappsfinal/glide-data-grid').TextCell | import('./lib/canvas').CanvasCell | import('@glideappsfinal/glide-data-grid').ImageCell | import('@glideappsfinal/glide-data-grid').BooleanCell | import('@glideappsfinal/glide-data-grid').MarkdownCell | import('@glideappsfinal/glide-data-grid').UriCell | import('@glideappsfinal/glide-data-grid').NumberCell | import('@glideappsfinal/glide-data-grid').CustomCell<{}> | import('@glideappsfinal/glide-data-grid').BubbleCell | import('@glideappsfinal/glide-data-grid').RowIDCell | import('@glideappsfinal/glide-data-grid').LoadingCell | import('@glideappsfinal/glide-data-grid').ProtectedCell | import('@glideappsfinal/glide-data-grid').DrilldownCell;
+export {};

package/components/TableGlide/classNames.d.ts

@@ -0,0 +1,5 @@
+export declare const classNames: {
+    glideScroller: string;
+    glideTable: string;
+    glideUnderlay: string;
+};

package/components/TableGlide/constants.d.ts

@@ -0,0 +1,126 @@
+import { RowSizeToken } from './theming/size-tokens';
+import { bodyXXS } from '../../tokens';
+import { TextCell } from '@glideappsfinal/glide-data-grid';
+
+export declare const DEFAULT_ROW_HEIGHT: {
+    readonly small: 20;
+    readonly medium: 32;
+    readonly big: 48;
+};
+export declare const EMPTY_CELL_OBJ: TextCell;
+export declare const SIZES: {
+    readonly big: {
+        readonly cellVerticalPadding: 12;
+        readonly cellHorizontalPadding: 16;
+        readonly textfieldSize: "s";
+    };
+    readonly medium: {
+        readonly cellVerticalPadding: 7;
+        readonly cellHorizontalPadding: 8;
+        readonly textfieldSize: "s";
+    };
+    readonly small: {
+        readonly cellVerticalPadding: 4;
+        readonly cellHorizontalPadding: 4;
+        readonly textfieldSize: "xs";
+    };
+};
+export type GlideSizes = typeof SIZES;
+export type SIZES = GlideSizes;
+export type SIZE = keyof GlideSizes;
+export type GlideSizeConfig = GlideSizes[SIZE];
+declare const EDITOR_CELL_PADDING: {
+    readonly 'padding-block': "0px";
+    readonly 'padding-inline': "0px";
+};
+export type TableGlideSizeConfig = {
+    rowHeight: number;
+    cell: {
+        'padding-block': `${number}px`;
+        'padding-inline': `${number}px`;
+    };
+    editorCell: typeof EDITOR_CELL_PADDING;
+    input: RowSizeToken['textfieldSize'];
+    icon: 'xs' | 's' | 'm';
+    combobox: 's' | 'm' | 'l';
+    checkboxOfCombobox: 's' | 'm' | 'l';
+    switch: 's' | 'l';
+    font: () => typeof bodyXXS;
+};
+export declare const TABLE_GLIDE_SIZES: {
+    readonly small: {
+        readonly rowHeight: 20 | 32 | 48;
+        readonly cell: {
+            readonly 'padding-block': `${number}px`;
+            readonly 'padding-inline': `${number}px`;
+        };
+        readonly editorCell: {
+            readonly 'padding-block': "0px";
+            readonly 'padding-inline': "0px";
+        };
+        readonly input: "s" | "xs";
+        readonly icon: "xs";
+        readonly combobox: "s";
+        readonly checkboxOfCombobox: "s";
+        readonly switch: "s";
+        readonly font: () => {
+            fontFamily: string;
+            fontSize: string;
+            fontStyle: string;
+            fontWeight: string;
+            letterSpacing: string;
+            lineHeight: string;
+        };
+    };
+    readonly medium: {
+        readonly rowHeight: 20 | 32 | 48;
+        readonly cell: {
+            readonly 'padding-block': `${number}px`;
+            readonly 'padding-inline': `${number}px`;
+        };
+        readonly editorCell: {
+            readonly 'padding-block': "0px";
+            readonly 'padding-inline': "0px";
+        };
+        readonly input: "s" | "xs";
+        readonly icon: "s";
+        readonly combobox: "m";
+        readonly checkboxOfCombobox: "m";
+        readonly switch: "s";
+        readonly font: () => {
+            fontFamily: string;
+            fontSize: string;
+            fontStyle: string;
+            fontWeight: string;
+            letterSpacing: string;
+            lineHeight: string;
+        };
+    };
+    readonly big: {
+        readonly rowHeight: 20 | 32 | 48;
+        readonly cell: {
+            readonly 'padding-block': `${number}px`;
+            readonly 'padding-inline': `${number}px`;
+        };
+        readonly editorCell: {
+            readonly 'padding-block': "0px";
+            readonly 'padding-inline': "0px";
+        };
+        readonly input: "s" | "xs";
+        readonly icon: "m";
+        readonly combobox: "l";
+        readonly checkboxOfCombobox: "l";
+        readonly switch: "l";
+        readonly font: () => {
+            fontFamily: string;
+            fontSize: string;
+            fontStyle: string;
+            fontWeight: string;
+            letterSpacing: string;
+            lineHeight: string;
+        };
+    };
+};
+export declare const COLUMN_MIN_WIDTH = 80;
+export declare const DEFAULT_HEADER_HEIGHT = 33;
+export {};

package/components/TableGlide/fonts.d.ts

@@ -0,0 +1,51 @@
+export declare const FONTS_CONFIG: {
+    bodyM: {
+        'font-size': string;
+        'font-weight': number;
+        'line-height': string;
+        'bold-font-size': string;
+        'bold-font-weight': number;
+        'bold-line-height': string;
+    };
+    bodyS: {
+        'font-size': string;
+        'font-weight': number;
+        'line-height': string;
+        'bold-font-size': string;
+        'bold-font-weight': number;
+        'bold-line-height': string;
+    };
+    bodyXS: {
+        'font-size': string;
+        'font-weight': number;
+        'line-height': string;
+        'bold-font-size': string;
+        'bold-font-weight': number;
+        'bold-line-height': string;
+    };
+    bodyXXS: {
+        'font-size': string;
+        'font-weight': number;
+        'line-height': string;
+        'bold-font-size': string;
+        'bold-font-weight': number;
+        'bold-line-height': string;
+    };
+};
+type FontObj = (typeof FONTS_CONFIG)[keyof typeof FONTS_CONFIG];
+type FontKeyInit = keyof typeof FONTS_CONFIG;
+type FontKey = FontKeyInit | `${FontKeyInit}Bold`;
+type FontMetric = {
+    fontSize: number;
+    lineHeightPx: number;
+};
+export type Fonts = {
+    [K in FontKey]: string;
+};
+export type FontMetrics = {
+    [K in FontKey]: FontMetric;
+};
+export declare const createFontStyle: (fontObj: FontObj, bold?: boolean) => string;
+export declare const fontStyles: Fonts;
+export declare const fontMetrics: FontMetrics;
+export {};

package/components/TableGlide/hooks/selection/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.rectContainsCell=e.rectContainsCell;exports.useBaseHighlightRegions=e.useBaseHighlightRegions;exports.useColumnRowHighlightRegions=e.useColumnRowHighlightRegions;exports.useNativeGridSelection=e.useNativeGridSelection;exports.useSelectionGeometry=e.useSelectionGeometry;exports.useTableSelectionSystem=e.useTableSelectionSystem;

package/components/TableGlide/hooks/selection/index.d.ts

@@ -0,0 +1,6 @@
+export { rectContainsCell } from './rectGeometry';
+export { useBaseHighlightRegions } from './useBaseHighlightRegions';
+export { useColumnRowHighlightRegions } from './useColumnRowHighlightRegions';
+export { useNativeGridSelection } from './useNativeGridSelection';
+export { useSelectionGeometry } from './useSelectionGeometry';
+export { useTableSelectionSystem } from './useTableSelectionSystem';

package/components/TableGlide/hooks/selection/index.mjs

@@ -0,0 +1,9 @@
+import { by as i, bz as o, bA as t, bB as a, bC as l, bD as n } from "../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  i as rectContainsCell,
+  o as useBaseHighlightRegions,
+  t as useColumnRowHighlightRegions,
+  a as useNativeGridSelection,
+  l as useSelectionGeometry,
+  n as useTableSelectionSystem
+};

package/components/TableGlide/hooks/selection/rectGeometry.d.ts

@@ -0,0 +1,7 @@
+import { Rectangle } from '@glideappsfinal/glide-data-grid';
+
+export declare const rectContainsCell: (rect: Rectangle | undefined, columnIndex: number, rowIndex: number) => boolean;
+export declare const findFirstDataColumnIndex: (columns: readonly {
+    isServiceColumn?: boolean;
+}[]) => number;
+export declare const clampRectToDataColumns: (rect: Rectangle | undefined, firstDataColumnIndex: number) => Rectangle | undefined;

package/components/TableGlide/hooks/selection/useActiveRowHighlight.d.ts

@@ -0,0 +1,10 @@
+interface UseActiveRowHighlightParams {
+    highlightActiveRow?: number;
+    onHighlightActiveRowChange?: (row: number | undefined) => void;
+    isHighlightActiveRowControlled?: boolean;
+}
+export declare function useActiveRowHighlight({ highlightActiveRow, onHighlightActiveRowChange, isHighlightActiveRowControlled, }: UseActiveRowHighlightParams): {
+    activeRow: number | undefined;
+    commitActiveRow: (value: number | undefined) => void;
+};
+export {};

package/components/TableGlide/hooks/selection/useBaseHighlightRegions.d.ts

@@ -0,0 +1,16 @@
+import { GlideProps, CellsSelectionMode, Theme } from '../../types';
+import { GridSelection, Rectangle } from '@glideappsfinal/glide-data-grid';
+
+interface UseBaseHighlightRegionsParams {
+    cellsSelectionMode: CellsSelectionMode;
+    selection: GridSelection;
+    baseTheme: Theme;
+    serviceColumnsCount: number;
+    activeDataRange?: Rectangle;
+    outlineRange?: Rectangle;
+    checkboxSelectedRowIndexes?: ReadonlySet<number>;
+    errorCellRanges?: readonly Rectangle[];
+    highlightRegionsExternal?: GlideProps['highlightRegions'];
+}
+export declare function useBaseHighlightRegions({ cellsSelectionMode, selection, baseTheme, serviceColumnsCount, activeDataRange, outlineRange, checkboxSelectedRowIndexes, errorCellRanges, highlightRegionsExternal, }: UseBaseHighlightRegionsParams): GlideProps['highlightRegions'];
+export {};

package/components/TableGlide/hooks/selection/useColumnAxisSelection.d.ts

@@ -0,0 +1,17 @@
+import { ColumnGlideLast, ObjectForExtending } from '../../types';
+import { CompactSelection } from '@glideappsfinal/glide-data-grid';
+
+interface UseColumnAxisSelectionParams<R extends ObjectForExtending, SR = unknown> {
+    columns: readonly ColumnGlideLast<R, SR>[];
+}
+export declare function useColumnAxisSelection<R extends ObjectForExtending, SR = unknown>({ columns }: UseColumnAxisSelectionParams<R, SR>): {
+    selectedColumns: CompactSelection;
+    setSelectedColumns: import('react').Dispatch<import('react').SetStateAction<CompactSelection>>;
+    selectedColumnIndexes: number[];
+    selectedColumnSet: Set<number>;
+    lastSelectedColumnRef: import('react').MutableRefObject<number | undefined>;
+    isNativeColumnSelection: boolean;
+    setIsNativeColumnSelection: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    clearColumnSelection: () => void;
+};
+export {};

package/components/TableGlide/hooks/selection/useColumnRowHighlightRegions.d.ts

@@ -0,0 +1,18 @@
+import { GlideProps, Theme } from '../../types';
+import { Rectangle } from '@glideappsfinal/glide-data-grid';
+
+interface UseColumnRowHighlightRegionsParams {
+    baseRegions: GlideProps['highlightRegions'];
+    selectedColumnIndexes: number[];
+    headerSelectedRowIndexes: number[];
+    activeRow?: number;
+    activeRange?: Rectangle;
+    selectionRangeStack?: readonly Rectangle[];
+    checkboxAvailableRowIndexes?: ReadonlySet<number>;
+    totalRows: number;
+    firstDataCol: number;
+    columnsCount: number;
+    theme: Theme;
+}
+export declare function useColumnRowHighlightRegions({ baseRegions, selectedColumnIndexes, headerSelectedRowIndexes, activeRow, activeRange, selectionRangeStack, checkboxAvailableRowIndexes, totalRows, firstDataCol, columnsCount, theme, }: UseColumnRowHighlightRegionsParams): GlideProps['highlightRegions'];
+export {};

package/components/TableGlide/hooks/selection/useNativeGridSelection.d.ts

@@ -0,0 +1,16 @@
+import { CellsSelectionMode } from '../../types';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+interface UseNativeGridSelectionParams {
+    cellsSelectionMode: CellsSelectionMode;
+    gridSelection?: GridSelection;
+    onGridSelectionChange?: (newSelection: GridSelection) => void;
+    onSelectionEmit?: (selection: GridSelection) => void;
+}
+export declare function useNativeGridSelection({ cellsSelectionMode, gridSelection: gridSelectionExternal, onGridSelectionChange: onGridSelectionChangeExternal, onSelectionEmit, }: UseNativeGridSelectionParams): {
+    selection: GridSelection;
+    handleGridSelectionChange: (next: GridSelection) => void;
+    handleSelectionCleared: () => void;
+    rangeSelect: "none" | "cell" | "rect" | "multi-cell" | "multi-rect" | undefined;
+};
+export {};

package/components/TableGlide/hooks/selection/useRowAxisSelection.d.ts

@@ -0,0 +1,12 @@
+import { CompactSelection } from '@glideappsfinal/glide-data-grid';
+
+export declare function useRowAxisSelection(): {
+    selectedRows: CompactSelection;
+    setSelectedRows: import('react').Dispatch<import('react').SetStateAction<CompactSelection>>;
+    headerSelectedRowIndexes: number[];
+    selectedRowsRef: import('react').MutableRefObject<CompactSelection>;
+    ctrlGestureRef: import('react').MutableRefObject<boolean>;
+    ctrlBaseRowsRef: import('react').MutableRefObject<CompactSelection>;
+    pointerGestureRef: import('react').MutableRefObject<boolean>;
+    clearRowSelection: () => void;
+};

package/components/TableGlide/hooks/selection/useSelectionGeometry.d.ts

@@ -0,0 +1,39 @@
+import { ColumnGlideLast, ObjectForExtending, CellsSelectionMode } from '../../types';
+import { GridSelection, Rectangle } from '@glideappsfinal/glide-data-grid';
+
+interface UseSelectionGeometryParams<R extends ObjectForExtending, SR = unknown> {
+    columns: readonly ColumnGlideLast<R, SR>[];
+    selection: GridSelection;
+    cellsSelectionMode: CellsSelectionMode;
+    checkboxSelectedRowIndexes?: ReadonlySet<number>;
+}
+export declare function useSelectionGeometry<R extends ObjectForExtending, SR = unknown>({ columns, selection, cellsSelectionMode, checkboxSelectedRowIndexes, }: UseSelectionGeometryParams<R, SR>): {
+    hasAnyActiveSelection: boolean;
+    firstDataColumnIndex: number;
+    leadingServiceColumnsCount: number;
+    activeRows: Set<number>;
+    activeColumns: Set<number>;
+    activeDataRange: Rectangle | undefined;
+    isSingleCellCustomHighlight: boolean;
+    outlineRange: Rectangle | undefined;
+    isServiceColumn: (colInd: number) => boolean;
+    isActiveRow: (_rowInd: number) => boolean;
+    isCheckboxSelectedRow: (rowInd: number) => boolean;
+    isActiveDataCell: (_colInd: number, _rowInd: number) => boolean;
+    isActiveHeaderColumn: (_colInd: number) => boolean;
+} | {
+    hasAnyActiveSelection: true;
+    firstDataColumnIndex: number;
+    leadingServiceColumnsCount: number;
+    activeRows: ReadonlySet<number>;
+    activeColumns: ReadonlySet<number>;
+    activeDataRange: Rectangle;
+    isSingleCellCustomHighlight: boolean;
+    outlineRange: Rectangle | undefined;
+    isServiceColumn: (colInd: number) => boolean;
+    isActiveRow: (rowInd: number) => boolean;
+    isCheckboxSelectedRow: (rowInd: number) => boolean;
+    isActiveDataCell: (colInd: number, rowInd: number) => boolean;
+    isActiveHeaderColumn: (colInd: number) => boolean;
+};
+export {};

package/components/TableGlide/hooks/selection/useTableSelectionSystem.d.ts

@@ -0,0 +1,35 @@
+import { ColumnGlideLast, GlideProps, HighlightActiveType, ObjectForExtending, CellsSelectionMode } from '../../types';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+type HeaderClickEvent = Parameters<NonNullable<GlideProps['onHeaderClicked']>>[1];
+interface UseTableSelectionSystemParams<R extends ObjectForExtending, SR = unknown> {
+    columns: readonly ColumnGlideLast<R, SR>[];
+    selection: GridSelection;
+    cellsSelectionMode: CellsSelectionMode;
+    highlightActiveType: HighlightActiveType;
+    enableColumnSelection: boolean;
+    enableRowSelection: boolean;
+    enableSelectAll: boolean;
+    leadingServiceColumnsCount: number;
+    dataRowCount: number;
+    handleGridSelectionChange: (next: GridSelection) => void;
+    handleSelectionCleared: () => void;
+    onSelectionEmit?: (next: GridSelection) => void;
+    highlightActiveRow?: number;
+    onHighlightActiveRowChange?: (row: number | undefined) => void;
+    isHighlightActiveRowControlled?: boolean;
+}
+export declare function useTableSelectionSystem<R extends ObjectForExtending, SR = unknown>({ columns, selection, cellsSelectionMode, highlightActiveType, enableColumnSelection, enableRowSelection, enableSelectAll, leadingServiceColumnsCount, dataRowCount, handleGridSelectionChange, handleSelectionCleared, onSelectionEmit, highlightActiveRow, onHighlightActiveRowChange, isHighlightActiveRowControlled, }: UseTableSelectionSystemParams<R, SR>): {
+    selectedColumnIndexes: number[];
+    selectedColumnKeysAll: string[];
+    selectColumnsByKeys: (keys: string[]) => void;
+    selectedColumnSet: Set<number>;
+    headerSelectedRowIndexes: number[];
+    activeRow: number | undefined;
+    numberingColumnIndex: number;
+    drawFocusRing: boolean;
+    selectColumnFromHeader: (columnIndex: number, event: HeaderClickEvent) => void;
+    handleGridSelectionWithColumnReset: (raw: GridSelection) => void;
+    handleSelectionClearedWithColumns: () => void;
+};
+export {};

package/components/TableGlide/hooks/useAnimatedRowHeight.d.ts

@@ -0,0 +1,3 @@
+import { RowHeightGlide } from '../types';
+
+export declare const useAnimatedRowHeight: (extRowHeight: RowHeightGlide) => RowHeightGlide;