@daisforge/ui 1.10.3

package/components/TableCanvas/types/table-config.type.d.ts

@@ -0,0 +1,303 @@
+import { Maybe, ObjectForExtending, Prettify } from './utils.type';
+import { ColumnConfig, EditingCellInfo, SortColumn } from './column-config.type';
+import { DomMetadata } from './additional.type';
+import { MassActionButtonProps } from '../widgets/mass-actions/types';
+import { FeatureItem, PinningMenuConfig, SidebarTab } from '../widgets/control-block/types';
+import { ControlBlockButtonProps } from '../widgets/control-block/control-block-button.types';
+import { CellReadOnlyEditorGlideInstanceStaticProps, CellsSelectionMode, HighlightActiveType, HoverEffectsConfig, TableGlideCustomProps, TableGlideInstanceProps, TableInfoWithRow } from '../TableGlideInstance/type';
+import { SubRows } from '../feature-tree/types';
+import { FlattenedRowsArrAndMap, SelectingRowConfig } from '../feature-select-row/types';
+import { SearchingProps } from '../feature-searching/types';
+import { RowsGrouping } from '../feature-rows-grouping/types';
+import { PaginationProps } from '../feature-pagination/types';
+import { TableNotificationsConfig } from '../feature-notifications';
+import { KeyTextConfig } from '../feature-key-text/types';
+import { FullScreen } from '../feature-full-screen/types';
+import { TableCanvasEmptyStateConfig, TableCanvasErrorStateConfig } from '../feature-content-state/types';
+import { ColumnsControlConfig } from '../feature-column-control/types';
+import { CellTransferConfig, FillMeta, RowsChangeType } from '../feature-cell-transfer/types';
+import { TableDropdownConfigProps } from '../components/TableDropdown/types';
+import { CSSObject } from 'styled-components';
+import { CSSProperties, ReactNode } from 'react';
+import { SIZE } from '..';
+import { MassActionsSize } from '../../MassActions';
+import { Group, Item, ItemOrGroup } from '../../ListOfFilters';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+export type ViewMods = {
+    rows: {
+        type: 'rows';
+        domMetadata?: DomMetadata;
+    };
+    cards: {
+        type: 'cards';
+        typeCardsRender: ReactNode;
+        domMetadata?: DomMetadata;
+    };
+    bothTypes: {
+        type: 'both-types';
+        typeCardsRender: ReactNode;
+        default?: 'cards' | 'rows';
+        domMetadata?: DomMetadata;
+    };
+};
+export interface RowsChangeData<R extends ObjectForExtending, SR = unknown> {
+    indexes: number[];
+    column: ColumnConfig<R, SR>;
+    rows: {
+        before: R;
+        after: R;
+    }[];
+    type: RowsChangeType;
+    fillMeta?: FillMeta;
+    fillResult?: string[][];
+}
+export type ActiveViewModsType = Exclude<keyof ViewMods, 'bothTypes'>;
+export type View = ViewMods['rows' | 'bothTypes' | 'cards'];
+export type { ControlBlockButtonProps };
+export type RowSize = {
+    showInControl: boolean;
+    default?: SIZE;
+    available?: SIZE[];
+    onRowSizeChange?: (size: SIZE) => void;
+    domMetadata?: DomMetadata;
+};
+export type RowHeightFunc<RowType> = (row: RowType, currentRowSize: {
+    rowSizeName: SIZE;
+    rowSizeValue: number;
+}, rowIndex: number) => number;
+export type TableCollapseConfig = {
+    enableCollapse?: boolean;
+    defaultCollapsed?: boolean;
+    collapseText?: string;
+    expandText?: string;
+    onToggleCollapse?: (isCollapsed: boolean) => void;
+    collapsedState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
+    domMetadata?: DomMetadata;
+    collapseButtonPlacement?: 'inside' | 'above';
+    collapseButtonAboveRightSlot?: React.ReactNode;
+    titleText?: string;
+    titleRender?: React.ReactNode;
+};
+export type { FlattenedRowsArrAndMap };
+export type FilteringConfig<T> = {
+    state: [T, React.Dispatch<React.SetStateAction<T>>];
+    clearedValue?: T;
+    filtersInfo?: Record<keyof T, {
+        label: string;
+        clearedValue: T[keyof T];
+    }>;
+    manualFiltering?: boolean;
+    sidebarConfig?: {
+        order?: string[];
+        items: Partial<Record<keyof T, {
+            label: string;
+            customRenderFn?: (filters: T, setFilters: React.Dispatch<React.SetStateAction<T>>) => React.ReactNode;
+        }>>;
+    };
+    chipStyle?: (itemOrGroup: ItemOrGroup, item: Item | undefined) => CSSObject;
+    renderGroupLabel?: (group: Group) => string;
+    renderChipLabel?: (group: Group | null, item: Item) => string;
+};
+export type DefaultSidebarTabIds = 'columns' | 'tableSettings' | 'filtering';
+export type SidebarConfig = {
+    enabled?: boolean;
+    defaultOpen?: boolean;
+    openState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
+    defaultActiveTabId?: string;
+    activeTabState?: [
+        string | null,
+        React.Dispatch<React.SetStateAction<string | null>>
+    ];
+    onActiveTabChange?: (tabId: string | null, tab?: SidebarTab) => void;
+    customTabs?: Array<Omit<SidebarTab, 'id'> & {
+        id: Exclude<string, DefaultSidebarTabIds>;
+    }>;
+    customTabsOrder?: Array<Exclude<string, DefaultSidebarTabIds>>;
+    defaultTabs?: Array<{
+        id: 'filtering' | 'columns';
+        label?: string;
+        title?: string;
+        domMetadata?: DomMetadata;
+        titleRightSlot?: React.ReactNode;
+    } | {
+        id: 'tableSettings';
+        label?: string;
+        title?: string;
+        domMetadata?: DomMetadata;
+        customGeneralSettingsSlot?: React.ReactNode;
+        titleRightSlot?: React.ReactNode;
+    }>;
+};
+export declare function activeViewIs<T extends 'cards' | 'rows'>(checkType: T, viewState: 'cards' | 'rows', view: View): view is ViewMods[T];
+export type ControlBlockSize = 'm' | 's' | 'xs';
+export type ControlBlockConfig = {
+    show?: boolean;
+    size?: ControlBlockSize;
+    leftSideInner?: ControlBlockButtonProps[];
+    rightSideInner?: ControlBlockButtonProps[];
+    customFeatures?: FeatureItem[];
+    pinningMenu?: PinningMenuConfig;
+    leftSideDropdownProps?: TableDropdownConfigProps;
+    rightSideDropdownProps?: TableDropdownConfigProps;
+    enableAdaptiveCompress?: boolean;
+    massActionPanel?: {
+        buttons: MassActionButtonProps[];
+        collapsedDropdownProps?: TableDropdownConfigProps;
+        bottom?: number;
+        show?: boolean;
+        size?: MassActionsSize;
+    };
+};
+export type EditingButtonProps = Omit<Partial<ControlBlockButtonProps>, 'onClick' | 'size' | 'dropdown' | 'isTargetAction' | 'skipRightDivider' | 'tooltipText'>;
+export type EditingConfig<RowType extends ObjectForExtending, RowIdType, SummaryRowType> = {
+    onRowsChange: Maybe<(rows: RowType[], data: RowsChangeData<RowType, SummaryRowType>) => void>;
+    subRowsKey?: string;
+    deepCloneRows?: boolean;
+    rowKeyGetter: (row: RowType) => RowIdType;
+    rowEditable?: (row: RowType) => boolean;
+    defaultEnabled?: boolean;
+    enabled?: boolean | [boolean, React.Dispatch<React.SetStateAction<boolean>>];
+    showButtons?: boolean;
+    onEnableEditing?: (enableEditorMode: () => void) => void;
+    onSave?: (disableEditorMode: () => void) => void;
+    onCancel?: (disableEditorMode: () => void) => void;
+    buttons?: {
+        save?: EditingButtonProps;
+        cancel?: EditingButtonProps;
+        edit?: EditingButtonProps;
+    };
+    editModeLeftSlot?: React.ReactNode;
+    domMetadata?: {
+        enableButton?: DomMetadata;
+        saveButton?: DomMetadata;
+        cancelButton?: DomMetadata;
+    };
+};
+export type SummaryRowsConfig = {
+    showDefault: boolean;
+    showInControl: boolean;
+} & {
+    domMetadata?: DomMetadata;
+};
+export type TableConfigTooltip = {
+    enabled?: boolean;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+};
+export type InfinityScrollConfig<RowType extends ObjectForExtending> = {
+    onTrigger: (rows: RowType[]) => Promise<void> | void;
+    isLoading: boolean;
+    hasMore?: boolean;
+    rowThreshold?: number;
+};
+export type { TableCanvasEmptyStateConfig, TableCanvasErrorStateConfig };
+export type CellsSelectionConfig = {
+    mode?: CellsSelectionMode;
+    enableColumnSelection?: boolean;
+    enableRowSelection?: boolean;
+    enableSelectAll?: boolean;
+    state?: [GridSelection, React.Dispatch<React.SetStateAction<GridSelection>>];
+};
+export type TableConfig<RowType extends ObjectForExtending, SummaryRowType, RowIdType extends string | number, FilterStateType extends ObjectForExtending> = {
+    highlightActiveType?: HighlightActiveType;
+    cellsSelection?: CellsSelectionConfig;
+    highlightActiveRow?: {
+        state?: [
+            number | undefined,
+            React.Dispatch<React.SetStateAction<number | undefined>>
+        ];
+        onChange?: (params: {
+            index: number | undefined;
+            row: RowType | undefined;
+        }) => void;
+    };
+    hoverEffects?: HoverEffectsConfig;
+    enableLowDprHairline?: boolean;
+    rowSize?: Prettify<RowSize>;
+    rowHeight?: Maybe<number | RowHeightFunc<RowType>>;
+    sorting?: {
+        state: [
+            readonly SortColumn[],
+            React.Dispatch<React.SetStateAction<readonly SortColumn[]>>
+        ];
+        manualSorting?: boolean;
+    };
+    view?: View;
+    filtering?: FilteringConfig<FilterStateType>;
+    collapsing?: TableCollapseConfig;
+    selecting?: {
+        state: [
+            ReadonlySet<RowIdType>,
+            React.Dispatch<React.SetStateAction<ReadonlySet<RowIdType>>>
+        ];
+        rowKeyGetter: (row: RowType) => RowIdType;
+    } & Prettify<SelectingRowConfig<RowType, RowIdType>> & {
+        controlBlock?: {
+            domMetadata?: DomMetadata;
+        };
+        sidebar?: {
+            domMetadata?: DomMetadata;
+        };
+    };
+    editing?: EditingConfig<RowType, RowIdType, SummaryRowType>;
+    cellTransfer?: CellTransferConfig;
+    notifications?: TableNotificationsConfig;
+    subRows?: SubRows<RowType, RowIdType>;
+    rowMarkers?: RowMarkersTableConfig<RowType>;
+    rowsGrouping?: RowsGrouping<RowType, SummaryRowType>;
+    resizableColumn?: boolean;
+    style?: Omit<CSSProperties, 'width' | 'height' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight'>;
+    css?: string | CSSObject;
+    summaryRows?: SummaryRowsConfig;
+    controlBlock?: ControlBlockConfig;
+    containerStyle?: CSSProperties | undefined;
+    containerCss?: string | CSSObject | undefined;
+    containerId?: string | undefined;
+    unstickyHeader?: boolean;
+    tooltip?: TableConfigTooltip;
+    infinityScroll?: InfinityScrollConfig<RowType>;
+    isLoading?: boolean | {
+        boolean: boolean;
+        skeletonRowsCount: number;
+    };
+    loadingOverlay?: {
+        active?: boolean;
+        spinner?: ReactNode;
+        title?: string;
+        subtitle?: string;
+        showSubtitleDelay?: number;
+    };
+    emptyState?: TableCanvasEmptyStateConfig;
+    errorState?: TableCanvasErrorStateConfig;
+    columnsControl?: ColumnsControlConfig;
+    fullScreenEnabled?: FullScreen;
+    editorOverlayPortal?: 'inside';
+    keyText?: boolean | KeyTextConfig;
+    pagination?: PaginationProps;
+    sidebarConfig?: SidebarConfig;
+    searching?: SearchingProps;
+    onHeaderContextMenu?: TableGlideInstanceProps<RowType, SummaryRowType>['onHeaderContextMenu'];
+    onHeaderContextMenuDropdown?: TableGlideInstanceProps<RowType, SummaryRowType>['onHeaderContextMenuDropdown'];
+    onCellContextMenuDropdown?: TableGlideInstanceProps<RowType, SummaryRowType>['onCellContextMenuDropdown'];
+    onCellContextMenu?: TableGlideInstanceProps<RowType, SummaryRowType>['onCellContextMenu'];
+    onCellClicked?: (cell: readonly [number, number], info: TableInfoWithRow<RowType, SummaryRowType>) => void;
+} & GlideInstanceOmitted<RowType, SummaryRowType>;
+type GlideInstanceOmitted<RowType extends ObjectForExtending, SummaryRowType> = Pick<Omit<TableGlideInstanceProps<RowType, SummaryRowType>, keyof TableGlideCustomProps<RowType, SummaryRowType> | 'CellReadOnlyEditor'>, 'className' | 'columnSelect' | 'minColumnWidth' | 'maxColumnWidth' | 'maxColumnAutoWidth' | 'onVisibleRegionChanged' | 'onCellClicked' | 'onHeaderClicked' | 'onItemHovered' | 'trapFocus' | 'onColumnResize'>;
+export type CellReadOnlyEditorProps<RowType extends ObjectForExtending, SummaryRowType> = CellReadOnlyEditorGlideInstanceStaticProps & EditingCellInfo<RowType, SummaryRowType>;
+export type RowMarkersTableConfig<RowType extends ObjectForExtending = ObjectForExtending> = {
+    startIndex?: number;
+    width?: number;
+    size?: 'xs' | 's' | 'm';
+    getRowMarker?: (args: {
+        row: RowType;
+        level: number;
+        isSubRow: boolean;
+        rowIndex: number;
+        flatIndex: number;
+        siblingIndex: number;
+        siblingPath: number[];
+        parentKey: string | number | null;
+        rows: readonly RowType[];
+    }) => string | number;
+};

package/components/TableCanvas/types/table.type.d.ts

@@ -0,0 +1,16 @@
+import { ObjectForExtending, Prettify } from './utils.type';
+import { TableConfig } from './table-config.type';
+import { ColumnConfig } from './column-config.type';
+import { DataEditorRef } from '../TableGlideInstance/type';
+import { Ref } from 'react';
+
+export type TableProps<FilterStateType extends ObjectForExtending, RowIdType extends string | number, HeaderContextValueType extends ObjectForExtending, RowContextValueType extends ObjectForExtending, RowType extends ObjectForExtending, SummaryRowType = unknown> = {
+    columnConfig: readonly ColumnConfig<RowType, SummaryRowType>[];
+    rows: RowType[];
+    bottomSummaryRows?: SummaryRowType[];
+    tableConfig?: Prettify<TableConfig<RowType, SummaryRowType, RowIdType, FilterStateType>>;
+    headerContextValue?: HeaderContextValueType;
+    rowContextValue?: RowContextValueType;
+    refTable?: Ref<DataEditorRef>;
+    refTableContainer?: React.Ref<HTMLDivElement>;
+};

package/components/TableCanvas/types/utils.type.d.ts

@@ -0,0 +1,12 @@
+export type ObjectForExtending = Record<string | number, any>;
+export type Key = string | number | bigint;
+export type Maybe<T> = T | undefined | null;
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type RequiredOnly<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type DataAttributes = {
+    [K in `data-${string}`]?: string;
+};

package/components/TableCanvas/utils/arrWithLength.d.ts

@@ -0,0 +1 @@
+export declare const arrWithLength: (length: number) => number[];

package/components/TableCanvas/utils/arrayMutationHandlers.d.ts

@@ -0,0 +1,3 @@
+export declare function removeAllFromArray<T>(arr: T[], isDeleteItem: (item: T) => boolean): T[];
+export declare function replaceAllFromArray<T>(arr: T[], isDeleteItem: (item: T) => boolean, add: T[]): T[];
+export declare function swapItemsByIndex<T>(arr: T[], i1: number, i2: number): void;

package/components/TableCanvas/utils/calculateMinColumnWidth.d.ts

@@ -0,0 +1,8 @@
+export declare function calculateMinColumnWidth(options: {
+    isHaveFiltering: boolean;
+    isHaveSorting: boolean;
+    columnIsPinned: boolean;
+    subRowIsActiveAndColumnWithArrow: boolean;
+    reorderForColIsActive?: boolean;
+    customMinWidth?: number;
+}): number;

package/components/TableCanvas/utils/classNames.d.ts

@@ -0,0 +1,3 @@
+import { Maybe, ObjectForExtending } from '../types';
+
+export declare const getCls: <R extends ObjectForExtending>(className: Maybe<string | ((row: R) => Maybe<string>)>, row: R) => Maybe<string>;

package/components/TableCanvas/utils/getClearedFilters.d.ts

@@ -0,0 +1,3 @@
+import { FilteringConfig } from '../types/table-config.type';
+
+export declare function getClearedFilters<T>(filtering?: FilteringConfig<T>): T | undefined;

package/components/TableCanvas/utils/getDataAttributes.d.ts

@@ -0,0 +1,4 @@
+import { FeatureItem } from '../widgets/control-block/types';
+import { DataAttributes } from '../types/utils.type';
+
+export declare const getDataAttributes: (obj: FeatureItem['details'] | FeatureItem) => DataAttributes;

package/components/TableCanvas/utils/getSymbolFromObj.d.ts

@@ -0,0 +1,5 @@
+import { ObjectForExtending } from '../types/utils.type';
+
+export declare const getSymbolFromObj: <T extends unknown>(obj: {
+    [key: symbol]: string;
+} & ObjectForExtending, symbol: symbol) => T | undefined;

package/components/TableCanvas/utils/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../chunks/TableCanvas-BmR3qLnY.cjs"),t=require("../../../chunks/utils-DN3rU1Iu.cjs");exports.calculateMinColumnWidth=e.calculateMinColumnWidth;exports.getDataAttributes=e.getDataAttributes;exports.overflowDotsStyle=e.overflowDotsStyle;exports.pasteOnlyKeysWithNotUndefinedValue=e.pasteOnlyKeysWithNotUndefinedValue;exports.setValueInObj=e.setValueInObj;exports.viewportToContainerPosition=e.viewportToContainerPosition;exports.tableDebug=t.tableDebug;

package/components/TableCanvas/utils/index.d.ts

@@ -0,0 +1,7 @@
+export { calculateMinColumnWidth } from './calculateMinColumnWidth';
+export { getDataAttributes } from './getDataAttributes';
+export { pasteOnlyKeysWithNotUndefinedValue } from './pasteOnlyKeysWithNotUndefinedValue';
+export { type FieldValues, setValueInObj } from './setValueInObj';
+export * from './styles';
+export { viewportToContainerPosition } from './viewportToContainerPosition';
+export { tableDebug } from '../../../utils/tableDebug';

package/components/TableCanvas/utils/index.mjs

@@ -0,0 +1,11 @@
+import { b7 as a, b8 as o, b9 as s, ba as b, bb as i, bc as l } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+import { x as r } from "../../../chunks/utils-Ch8gMTzR.mjs";
+export {
+  a as calculateMinColumnWidth,
+  o as getDataAttributes,
+  s as overflowDotsStyle,
+  b as pasteOnlyKeysWithNotUndefinedValue,
+  i as setValueInObj,
+  r as tableDebug,
+  l as viewportToContainerPosition
+};

package/components/TableCanvas/utils/pasteOnlyKeysWithNotUndefinedValue.d.ts

@@ -0,0 +1,3 @@
+import { ObjectForExtending } from '../types/utils.type';
+
+export declare const pasteOnlyKeysWithNotUndefinedValue: <T extends ObjectForExtending>(v: T) => T;

package/components/TableCanvas/utils/setValueInObj.d.ts

@@ -0,0 +1,3 @@
+export type FieldValues = Record<string, any>;
+export declare const setValueInObj: (object: FieldValues, path: string, value?: unknown) => FieldValues | undefined;
+export declare const getValueInObj: <O extends Record<string, unknown>, K extends string>(obj: O, path: K) => import('../../../utils').TGetValue<O, K>;

package/components/TableCanvas/utils/styles.d.ts

@@ -0,0 +1,5 @@
+export declare const overflowDotsStyle: {
+    whiteSpace: string;
+    overflow: string;
+    textOverflow: string;
+};

package/components/TableCanvas/utils/viewportToContainerPosition.d.ts

@@ -0,0 +1,4 @@
+export declare function viewportToContainerPosition(viewportX: number, viewportY: number, container: HTMLElement): {
+    x: number;
+    y: number;
+};

package/components/TableCanvas/widgets/control-block/ControlBlock.d.ts

@@ -0,0 +1,51 @@
+import { FeatureItem, ToolsMenuState } from './types';
+import { ControlBlockButtonProps } from './control-block-button.types';
+import { TableDropdownConfigProps } from '../../components/TableDropdown/types';
+import { default as React } from 'react';
+import { ActiveViewModsType } from '../../types';
+
+type ActivatedFeatures = {
+    viewChanging: boolean;
+    rowSize: boolean;
+    columnsControl: boolean;
+    summaryRows: boolean;
+    selectingRows: boolean;
+    fullScreen: boolean;
+    rowInstruments: boolean;
+    keyText: boolean;
+    rowsGrouping: boolean;
+    editingMode: boolean;
+    searching: boolean;
+    filtering: boolean;
+};
+export declare const ControlBlock: ({ leftSideInner, rightSideInner, isHaveControlBlock, activeView, fullScreened, editModeEnabled, editModeLeftSlot, featuresObj: { isActivated, icons, featureItems, featureRightButtons, featureLeftButtons, featureSearching: { isActiveSearching, showSearchBlock, searchQueryLocalValue, placeholderSearchBlock } }, $borderTopRounded, setCompressionVisibility, controlBlockLeftSideDropdownProps, controlBlockRightSideDropdownProps, collapseButtonPlacement, controlBlockSize }: {
+    leftSideInner: ControlBlockButtonProps[] | undefined;
+    rightSideInner: ControlBlockButtonProps[] | undefined;
+    editModeEnabled: boolean;
+    editModeLeftSlot?: React.ReactNode;
+    fullScreened: boolean;
+    isHaveControlBlock: boolean | undefined;
+    activeView: ActiveViewModsType;
+    featuresObj: {
+        isActivated: ActivatedFeatures;
+        icons: FeatureItem[];
+        featureItems: FeatureItem[];
+        all: FeatureItem[];
+        featureRightButtons: ControlBlockButtonProps[];
+        featureLeftButtons: ControlBlockButtonProps[];
+        featureSearching: {
+            isActiveSearching: boolean;
+            showSearchBlock: boolean;
+            setShowSearchBlock: React.Dispatch<React.SetStateAction<boolean>>;
+            searchQueryLocalValue: string;
+            placeholderSearchBlock: string;
+        };
+    };
+    $borderTopRounded: boolean;
+    setCompressionVisibility: React.Dispatch<React.SetStateAction<ToolsMenuState | undefined>>;
+    controlBlockLeftSideDropdownProps?: TableDropdownConfigProps;
+    controlBlockRightSideDropdownProps?: TableDropdownConfigProps;
+    collapseButtonPlacement?: 'inside' | 'above';
+    controlBlockSize?: import('../../types').ControlBlockSize;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/components/TableCanvas/widgets/control-block/ControlBlock.lazy.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="react" />
+export declare const ControlBlockLazy: import('react').LazyExoticComponent<({ leftSideInner, rightSideInner, isHaveControlBlock, activeView, fullScreened, editModeEnabled, editModeLeftSlot, featuresObj: { isActivated, icons, featureItems, featureRightButtons, featureLeftButtons, featureSearching: { isActiveSearching, showSearchBlock, searchQueryLocalValue, placeholderSearchBlock } }, $borderTopRounded, setCompressionVisibility, controlBlockLeftSideDropdownProps, controlBlockRightSideDropdownProps, collapseButtonPlacement, controlBlockSize }: {
+    leftSideInner: import('./control-block-button.types').ControlBlockButtonProps[] | undefined;
+    rightSideInner: import('./control-block-button.types').ControlBlockButtonProps[] | undefined;
+    editModeEnabled: boolean;
+    editModeLeftSlot?: import('react').ReactNode;
+    fullScreened: boolean;
+    isHaveControlBlock: boolean | undefined;
+    activeView: import('../..').ActiveViewModsType;
+    featuresObj: {
+        isActivated: {
+            viewChanging: boolean;
+            rowSize: boolean;
+            columnsControl: boolean;
+            summaryRows: boolean;
+            selectingRows: boolean;
+            fullScreen: boolean;
+            rowInstruments: boolean;
+            keyText: boolean;
+            rowsGrouping: boolean;
+            editingMode: boolean;
+            searching: boolean;
+            filtering: boolean;
+        };
+        icons: import('./types').FeatureItem[];
+        featureItems: import('./types').FeatureItem[];
+        all: import('./types').FeatureItem[];
+        featureRightButtons: import('./control-block-button.types').ControlBlockButtonProps[];
+        featureLeftButtons: import('./control-block-button.types').ControlBlockButtonProps[];
+        featureSearching: {
+            isActiveSearching: boolean;
+            showSearchBlock: boolean;
+            setShowSearchBlock: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+            searchQueryLocalValue: string;
+            placeholderSearchBlock: string;
+        };
+    };
+    $borderTopRounded: boolean;
+    setCompressionVisibility: import('react').Dispatch<import('react').SetStateAction<import('./types').ToolsMenuState | undefined>>;
+    controlBlockLeftSideDropdownProps?: import('../../components/TableDropdown/types').TableDropdownConfigProps | undefined;
+    controlBlockRightSideDropdownProps?: import('../../components/TableDropdown/types').TableDropdownConfigProps | undefined;
+    collapseButtonPlacement?: "inside" | "above" | undefined;
+    controlBlockSize?: import('../..').ControlBlockSize | undefined;
+}) => import("react/jsx-runtime").JSX.Element>;

package/components/TableCanvas/widgets/control-block/ControlBlockWithoutResize.d.ts

@@ -0,0 +1,28 @@
+import { FeatureItem } from './types';
+import { ControlBlockButtonProps } from './control-block-button.types';
+import { default as React } from 'react';
+import { ActiveViewModsType, ControlBlockSize } from '../../types';
+
+export declare const ControlBlockWithoutResize: ({ leftSideInner, rightSideInner, isHaveControlBlock, activeView, featuresObj: { icons, featureItems, featureRightButtons, featureLeftButtons, featureSearching: { isActiveSearching, showSearchBlock, searchQueryLocalValue, placeholderSearchBlock } }, $borderTopRounded, collapseButtonPlacement, controlBlockSize }: {
+    leftSideInner: ControlBlockButtonProps[] | undefined;
+    rightSideInner: ControlBlockButtonProps[] | undefined;
+    isHaveControlBlock: boolean | undefined;
+    activeView: ActiveViewModsType;
+    controlBlockSize?: ControlBlockSize;
+    featuresObj: {
+        icons: FeatureItem[];
+        featureItems: FeatureItem[];
+        all: FeatureItem[];
+        featureRightButtons: ControlBlockButtonProps[];
+        featureLeftButtons: ControlBlockButtonProps[];
+        featureSearching: {
+            isActiveSearching: boolean;
+            showSearchBlock: boolean;
+            setShowSearchBlock: React.Dispatch<React.SetStateAction<boolean>>;
+            searchQueryLocalValue: string;
+            placeholderSearchBlock: string;
+        };
+    };
+    $borderTopRounded: boolean;
+    collapseButtonPlacement?: 'inside' | 'above';
+}) => import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/widgets/control-block/compression/cache.d.ts

@@ -0,0 +1,6 @@
+import { CompressionCache, ToolsMenuState } from '../types';
+
+export declare const cloneState: (state: ToolsMenuState) => ToolsMenuState;
+export declare const getOrCreateElementCache: (element: HTMLDivElement | null | undefined) => CompressionCache;
+export declare const findCachedState: (cache: CompressionCache, key: string, width: number) => ToolsMenuState | null;
+export declare const addToCache: (cache: CompressionCache, key: string, width: number, state: ToolsMenuState, stateWidth: number, originalState: ToolsMenuState) => void;

package/components/TableCanvas/widgets/control-block/compression/debug.d.ts

@@ -0,0 +1,20 @@
+import { InitialWidthsForToolsMenu, ToolsMenuState } from '../types';
+
+export declare const isCompressionDebugEnabled: () => boolean;
+export type DebugStep = {
+    step: string;
+    widthAfter: number;
+    fits: boolean;
+};
+export declare const debugSkip: (reason: string, availableWidth: number) => void;
+export declare const debugLogInit: (initialState: ToolsMenuState, measuredWidths: InitialWidthsForToolsMenu | undefined, spacing: Record<string, number>, options: Record<string, unknown> | undefined) => void;
+export declare const debugLogCompress: (data: {
+    availableWidth: number;
+    contentWidthBefore: number;
+    steps: DebugStep[];
+    finalState: ToolsMenuState;
+    fromCache: boolean;
+    measuredWidths: InitialWidthsForToolsMenu | undefined;
+    breakdown?: Record<string, number>;
+}) => void;
+export declare const debugResetInit: () => void;

package/components/TableCanvas/widgets/control-block/compression/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});require("react");const e=require("../../../../../chunks/TableCanvas-BmR3qLnY.cjs");exports.useCompressionFeatures=e.useCompressionFeatures;exports.useControlBlockMeasurements=e.useControlBlockMeasurements;exports.useMeasurementEffects=e.useMeasurementEffects;

package/components/TableCanvas/widgets/control-block/compression/index.d.ts

@@ -0,0 +1,9 @@
+import { CompressionOptions, CompressionSpacing, InitialWidthsForToolsMenu, ToolsMenuState } from '../types';
+
+export { useControlBlockMeasurements, useMeasurementEffects } from './measure';
+export declare const useCompressionFeatures: (initialState: ToolsMenuState, measuredWidths: InitialWidthsForToolsMenu | undefined, element: HTMLDivElement | null | undefined, spacing: CompressionSpacing, options?: CompressionOptions) => {
+    compressedState: ToolsMenuState;
+    compress: (availableWidth: number) => void;
+    calculateCurrentWidth: (state: ToolsMenuState, breakdown?: Record<string, number>) => number;
+    resetCompression: () => void;
+};

package/components/TableCanvas/widgets/control-block/compression/index.mjs

@@ -0,0 +1,7 @@
+import "react";
+import { cs as r, ct as t, cu as u } from "../../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  r as useCompressionFeatures,
+  t as useControlBlockMeasurements,
+  u as useMeasurementEffects
+};

package/components/TableCanvas/widgets/control-block/compression/measure.d.ts

@@ -0,0 +1,30 @@
+import { FeatureItem, FeatureRefTarget, InitialWidthsForToolsMenu, ToolsMenuState } from '../types';
+import { ControlBlockButtonProps } from '../control-block-button.types';
+import { default as React } from 'react';
+
+type MeasurementsParams = {
+    leftSideInner: ControlBlockButtonProps[] | undefined;
+    rightButtons: ControlBlockButtonProps[];
+    featureLeftButtons: ControlBlockButtonProps[];
+    icons: FeatureItem[];
+};
+export type ControlBlockMeasurements = ReturnType<typeof useControlBlockMeasurements>;
+export declare const useControlBlockMeasurements: ({ leftSideInner, rightButtons, featureLeftButtons, icons }: MeasurementsParams) => {
+    mergedWidths: InitialWidthsForToolsMenu;
+    registerFeaturesRef: (el: HTMLDivElement | null, index: number, target: FeatureRefTarget) => void;
+    measureAll: (vis: ToolsMenuState, iconsList: FeatureItem[]) => void;
+    logDomZones: (container: HTMLDivElement | null) => void;
+    inlineTitleRef: React.RefObject<HTMLSpanElement>;
+    editModeLeftSlotRef: React.RefObject<HTMLDivElement>;
+    overflowTriggerRef: React.RefObject<HTMLDivElement>;
+    leftSideInnerBlockRef: React.RefObject<HTMLDivElement>;
+};
+type MeasurementEffectsParams = MeasurementsParams & {
+    visibilityState: ToolsMenuState;
+    containerRef: React.RefObject<HTMLDivElement>;
+    fullScreened: boolean;
+    editModeEnabled: boolean;
+    isCollapsed: boolean;
+};
+export declare const useMeasurementEffects: (measurements: ControlBlockMeasurements, { visibilityState, containerRef, leftSideInner, rightButtons, featureLeftButtons, icons, fullScreened, editModeEnabled, isCollapsed }: MeasurementEffectsParams) => void;
+export {};

package/components/TableCanvas/widgets/control-block/compression/steps.d.ts

@@ -0,0 +1,13 @@
+import { ToolsMenuState } from '../types';
+
+export type CompressionContext = {
+    isEditMode: boolean;
+    allowSearchShrink: boolean;
+    hasGroupingCounter: boolean;
+};
+export type CompressionStep = {
+    name: string;
+    applies: (state: ToolsMenuState, ctx: CompressionContext) => boolean;
+    apply: (state: ToolsMenuState) => void;
+};
+export declare const getCompressionPipeline: (ctx: CompressionContext) => CompressionStep[];