@daisforge/ui 1.10.3

package/components/TableCanvas/feature-searching/types.d.ts

@@ -0,0 +1,30 @@
+import { DomMetadata } from '../types/additional.type';
+import { ComponentProps } from 'react';
+import { IconProps } from '../../../icons';
+import { TextField } from '../../TextField';
+import { AutocompleteProps } from '../../Autocomplete/Autocomplete.types';
+
+export type SearchAutocompleteConfig = Pick<AutocompleteProps, 'suggestions' | 'onSuggestionSelect' | 'threshold' | 'renderList' | 'renderListEnd' | 'beforeList' | 'listMaxHeight' | 'listWidth' | 'portal' | 'hasDivider' | 'beforeList' | 'afterList' | 'virtual' | 'hasDivider' | 'onScroll' | 'zIndex' | 'filter' | 'renderItem'>;
+type TProps = Omit<ComponentProps<typeof TextField>, 'value' | 'onChange' | 'onKeyDown' | 'contentLeft' | 'contentRight' | 'clear'>;
+export interface SearchBlockProps extends TProps {
+    isVisible?: boolean;
+    iconSize?: IconProps['size'];
+    $isFullHeight?: boolean;
+}
+export type SearchingProps = {
+    enabled: boolean;
+    manualSearching?: boolean;
+    defaultSearchQuery?: string;
+    showSearchBlock?: boolean;
+    searchQueryState?: [string, React.Dispatch<React.SetStateAction<string>>];
+    onDebouncedChange?: (value: string) => void;
+    onChange?: (value: string) => void;
+    debounceDelay?: number;
+    isDebounceActive?: boolean;
+    searchClasses?: string;
+    placeholder?: string;
+    domMetadata?: DomMetadata;
+    searchOnType?: boolean;
+    autocomplete?: SearchAutocompleteConfig;
+};
+export {};

package/components/TableCanvas/feature-select-row/checbox-column.d.ts

@@ -0,0 +1,6 @@
+import { ColumnConfigInternal } from '../types/column-config-internal.type';
+import { SIZE } from '../styles/styles.constants';
+
+export declare const createCheckboxColumn: ({ rowSize }: {
+    rowSize: SIZE;
+}) => ColumnConfigInternal<any, unknown>;

package/components/TableCanvas/feature-select-row/checkbox-metrics.d.ts

@@ -0,0 +1,13 @@
+import { SIZE } from '../styles/styles.constants';
+
+type CheckboxMetrics = {
+    checkboxSize: number;
+    cellWidth: number;
+    cellHeight: number;
+    columnWidth: number;
+};
+export declare const getCheckboxMetricsByRowSize: (rowSize?: SIZE) => CheckboxMetrics;
+export declare const getCheckboxMetricsByTheme: (theme: {
+    cellVerticalPadding?: number;
+}) => CheckboxMetrics;
+export {};

package/components/TableCanvas/feature-select-row/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const SELECTING_KEYS: {
+    level: "level";
+    parent: "parent";
+};
+export declare const SELECTING_RULES_DEFAULT: {
+    levels: number;
+    changebleDisabledRow: boolean;
+    changebleOfRowWithoutCheckbox: boolean;
+};
+export declare const CHECKBOX_COLUMN_KEY = "checkbox-row";
+export declare const CHECKBOX_COL_CLASS_CUSTOM = "checkbox-column-custom";
+export declare const CHECKBOX_HEADER_COL_CLASS_CUSTOM = "checbox-header-column-custom";
+export declare const CHECKBOX_SUMMARY_COL_CLASS_CUSTOM = "checbox-summary-column-custom";

package/components/TableCanvas/feature-select-row/handlers.d.ts

@@ -0,0 +1,22 @@
+import { SelectingRowConfig } from './types';
+import { SELECTING_KEYS } from './constants';
+import { ObjectForExtending } from '../types/utils.type';
+
+export declare const flatten: <RowType extends ObjectForExtending>(arr: RowType[], getChildren: (item: RowType) => RowType[] | undefined, getParent: (item: RowType) => RowType | null, level?: number, parent?: RowType | null, customProps?: (level: number, row: RowType, parent: RowType | null) => ObjectForExtending, filterCb?: (level: number, row: RowType, parent: RowType | null) => boolean) => Array<RowType & {
+    [SELECTING_KEYS.level]: number;
+    [SELECTING_KEYS.parent]: RowType | null;
+    customProps: ObjectForExtending;
+}>;
+export interface ObjectWithParentAndId {
+    id: string | number;
+    parent?: {
+        id: string | number;
+        parent?: ObjectWithParentAndId;
+    };
+}
+export declare const getAllParents: <T extends ObjectWithParentAndId>(item: T, flattenedOptions: T[], rowKeyGetter: (row: ObjectForExtending) => string | number) => {
+    allParents: Map<string | number, ObjectForExtending>;
+};
+export declare const getCustomOrDefaultSelectingRules: <RowType, RowIdType extends string | number>(selectingRules: SelectingRowConfig<RowType, RowIdType>['selectingRules']) => {
+    levels: number | "all" | number[] | ((lvl: number) => boolean);
+};

package/components/TableCanvas/feature-select-row/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const C=require("../../../chunks/TableCanvas-BmR3qLnY.cjs");exports.CHECKBOX_COLUMN_KEY=C.CHECKBOX_COLUMN_KEY;exports.CHECKBOX_COL_CLASS_CUSTOM=C.CHECKBOX_COL_CLASS_CUSTOM;exports.CHECKBOX_HEADER_COL_CLASS_CUSTOM=C.CHECKBOX_HEADER_COL_CLASS_CUSTOM;exports.CHECKBOX_SUMMARY_COL_CLASS_CUSTOM=C.CHECKBOX_SUMMARY_COL_CLASS_CUSTOM;exports.SELECTING_KEYS=C.SELECTING_KEYS;exports.SELECTING_RULES_DEFAULT=C.SELECTING_RULES_DEFAULT;exports.createCheckboxColumn=C.createCheckboxColumn;exports.flatten=C.flatten;

package/components/TableCanvas/feature-select-row/index.d.ts

@@ -0,0 +1,3 @@
+export * from './checbox-column';
+export * from './constants';
+export { flatten } from './handlers';

package/components/TableCanvas/feature-select-row/index.mjs

@@ -0,0 +1,11 @@
+import { C as E, h as S, i as L, j as O, k as a, l as s, m as U, n as A } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  E as CHECKBOX_COLUMN_KEY,
+  S as CHECKBOX_COL_CLASS_CUSTOM,
+  L as CHECKBOX_HEADER_COL_CLASS_CUSTOM,
+  O as CHECKBOX_SUMMARY_COL_CLASS_CUSTOM,
+  a as SELECTING_KEYS,
+  s as SELECTING_RULES_DEFAULT,
+  U as createCheckboxColumn,
+  A as flatten
+};

package/components/TableCanvas/feature-select-row/selecting-contexts.d.ts

@@ -0,0 +1,70 @@
+import { FlattenedRowsArrAndMap, SelectingRowConfig } from './types';
+import { ObjectForExtending } from '../types/utils.type';
+import { DomMetadata } from '../types/additional.type';
+import { CellInfoGlideInstance } from '../TableGlideInstance/type';
+import { default as React, PropsWithChildren } from 'react';
+
+export interface RowSelectionContextValue {
+    readonly isRowSelected: boolean;
+    readonly isRowSelectionDisabled: boolean;
+}
+type RowIdTypeInstance = string | number;
+export type SelectingContextType<RowType extends ObjectForExtending = ObjectForExtending, RowIdType extends RowIdTypeInstance = RowIdTypeInstance> = {
+    rows: RowType[];
+    selectingRowConfig: SelectingRowConfig<RowType, RowIdType> & {
+        selectingRowsIsActive: boolean;
+    };
+    flattenedRowsArrAndMap: FlattenedRowsArrAndMap<RowType, RowIdType> | null;
+    selectedRows: ReadonlySet<string | number> | undefined;
+    setSelectedRows: React.Dispatch<React.SetStateAction<ReadonlySet<RowIdType>>> | undefined;
+    rowKeyGetter: undefined | ((row: RowType) => RowIdType);
+    rowsGroupingIsActive: boolean;
+    isRowsGroupingLabelVisible: boolean;
+    setIsRowsGroupingLabelVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    isRowsGroupingCounterVisible: boolean;
+    setIsRowsGroupingCounterVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    isSelectingRowLabelVisible: boolean;
+    setIsSelectingRowLabelVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    isSelectingRowCounterVisible: boolean;
+    setIsSelectingRowCounterVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    controlBlock?: {
+        domMetadata?: DomMetadata;
+    };
+    sidebar?: {
+        domMetadata?: DomMetadata;
+    };
+};
+export declare const SelectingContextProvider: <RowIdType extends string | number, RowType extends ObjectForExtending>({ children, ...rest }: PropsWithChildren & {
+    rows: RowType[];
+    selectingRowConfig: SelectingRowConfig<RowType, RowIdType> & {
+        selectingRowsIsActive: boolean;
+    };
+    flattenedRowsArrAndMap: FlattenedRowsArrAndMap<RowType, RowIdType> | null;
+    selectedRows: ReadonlySet<string | number> | undefined;
+    setSelectedRows: React.Dispatch<React.SetStateAction<ReadonlySet<RowIdType>>> | undefined;
+    rowKeyGetter: undefined | ((row: RowType) => RowIdType);
+    rowsGroupingIsActive: boolean;
+    isRowsGroupingLabelVisible: boolean;
+    setIsRowsGroupingLabelVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    isRowsGroupingCounterVisible: boolean;
+    setIsRowsGroupingCounterVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    isSelectingRowLabelVisible: boolean;
+    setIsSelectingRowLabelVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    isSelectingRowCounterVisible: boolean;
+    setIsSelectingRowCounterVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    controlBlock?: {
+        domMetadata?: DomMetadata;
+    };
+    sidebar?: {
+        domMetadata?: DomMetadata;
+    };
+}) => import("react/jsx-runtime").JSX.Element;
+export declare function useSelectingRowContext<R extends ObjectForExtending = ObjectForExtending>(): SelectingContextType<R, RowIdTypeInstance>;
+export declare const getRowSelectingInfo: <RowType extends ObjectForExtending>(renderCellProps: CellInfoGlideInstance<RowType>) => {
+    isRowSelected: boolean;
+    isIndeterminate: boolean;
+    isRowSelectionDisabled: boolean;
+    isHaveCheckbox: boolean;
+    onChange: () => void;
+};
+export {};

package/components/TableCanvas/feature-select-row/summary-checkbox.d.ts

@@ -0,0 +1,13 @@
+import { CanvasEl, HeaderCellInfoGlideInstance } from '../TableGlideInstance';
+import { MutableRefObject } from 'react';
+
+export declare const renderSummaryCheckbox: ({ ctxs, theme }: HeaderCellInfoGlideInstance<any, unknown>) => CanvasEl;
+export declare const SummaryCheckbox: ({ isHaveRightDivider, hideCheckbox, renderOnlyCheckbox, onChangeHandlerRef }: {
+    isHaveRightDivider: boolean;
+    hideCheckbox?: boolean;
+    renderOnlyCheckbox?: boolean;
+    onChangeHandlerRef?: MutableRefObject<(arg: {
+        clearButtonClicked: true;
+        checkedAll: true;
+    }) => void>;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/components/TableCanvas/feature-select-row/types.d.ts

@@ -0,0 +1,136 @@
+import { SELECTING_KEYS } from './constants';
+import { ObjectForExtending } from '../types/utils.type';
+import { GroupRow } from '../feature-rows-grouping/types';
+import { ChangeEvent } from 'react';
+
+export type ChildrenInfo<RowType, RowIdType> = {
+    all: RowType[];
+    disabled: RowIdType[];
+    notDisabled: RowIdType[];
+    notDisabledAndNotHidden: RowIdType[];
+    notDisabledAndNotHiddenAreSelected: boolean;
+    hidden: RowIdType[];
+    notHidden: RowIdType[];
+    selected: RowIdType[];
+    notSelected: RowIdType[];
+    someChildrenIsSelected: boolean;
+};
+export type RowKeyGetter<RowType, RowIdType> = (row: RowType) => RowIdType;
+export type RowShowCheckbox<RowType> = (row: RowType, lvl?: number, parent?: RowType | null) => boolean;
+export type RowCheckboxDisabled<RowType> = (row: RowType, lvl?: number, parent?: RowType | null) => boolean;
+export type RowGetStatesProps<RowType, RowIdType> = {
+    isHaveCheckboxCalculated: boolean;
+    isRowSelectedCalculated: boolean;
+    isIndeterminateCalculated: boolean;
+    isRowSelectionDisabled: boolean;
+    rowKeyGetter: RowKeyGetter<RowType, RowIdType>;
+    row: RowType;
+    flattenedRowsMap: Map<RowIdType, RowType & {
+        level?: number;
+        parent?: RowType | null | undefined;
+    }>;
+    selectedRows: ReadonlySet<RowIdType>;
+    setSelectedRows: React.Dispatch<React.SetStateAction<ReadonlySet<RowIdType>>>;
+    level: number;
+    parent: RowType | null;
+    getRowChildrenInfo: () => ChildrenInfo<RowType, RowIdType>;
+    rowShowCheckbox: RowShowCheckbox<RowType> | undefined;
+    rowCheckboxDisabled: RowCheckboxDisabled<RowType> | undefined;
+};
+export type RowGetStatesReturnType<RowType, RowIdType> = {
+    checked?: boolean | null;
+    indeterminate?: boolean | null;
+    showCheckbox?: boolean | null;
+    checkboxDisabled?: boolean | null;
+    onChange?: ((p: {
+        allParentsMap: Map<RowIdType, RowType>;
+        isRowInLevels: (row: RowType) => boolean;
+        defaultSetter: () => void;
+        getRowParentsInfo: () => {
+            all: RowType[];
+            getShouldBeSelectedInfo: (actualSelecteds: ReadonlySet<RowIdType>) => {
+                shouldBeSelected: RowIdType[];
+                shouldNotBeSelected: RowIdType[];
+            };
+        };
+    }) => void) | null;
+};
+export type SummaryCheckedFunc<RowType, ReturnType, AdditionalPropsObj extends ObjectForExtending | void = void, RowIdType extends string | number = string | number> = (props: {
+    rows: RowType[];
+    flattenedRows: (RowType & {
+        level?: number;
+        parent?: RowType | null;
+    })[];
+    selectedRowsIds: ReadonlySet<RowIdType>;
+    rowKeyGetter: (row: RowType) => RowIdType;
+    rowCheckboxDisabled: RowCheckboxDisabled<RowType>;
+    rowShowCheckbox: RowShowCheckbox<RowType>;
+    allRowsInLevels: (RowType & {
+        level?: number;
+        parent?: RowType | null;
+    })[];
+    getAllRowsInfo: () => ChildrenInfo<RowType, RowIdType>;
+} & (AdditionalPropsObj extends ObjectForExtending ? AdditionalPropsObj : {})) => ReturnType;
+export type SelectingRowConfig<RowType, RowIdType extends string | number> = {
+    showDefault?: boolean;
+    showState?: [boolean, React.Dispatch<React.SetStateAction<boolean>>];
+    showInControl?: boolean;
+    selectingRules?: {
+        levels?: number | 'all' | number[] | ((lvl: number) => boolean);
+    };
+    disableSummaryCheckboxInHeader?: boolean;
+    hideSummaryCheckboxInHeader?: boolean;
+    hideSummaryCheckbox?: boolean;
+    summaryChecked?: {
+        checked: boolean | SummaryCheckedFunc<RowType, boolean>;
+        indeterminate: boolean | SummaryCheckedFunc<RowType, boolean, {
+            checkedAll: boolean;
+        }>;
+        getCountOfChecked: SummaryCheckedFunc<RowType, number>;
+        onChange: SummaryCheckedFunc<RowType, void, {
+            checkedAll: boolean;
+            clearButtonClicked?: boolean;
+            setSelectedRowsIds: React.Dispatch<React.SetStateAction<ReadonlySet<string | number>>>;
+        }>;
+    };
+    summaryCheckedUncontrolled?: {
+        onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    };
+    rowShowCheckbox?: RowShowCheckbox<RowType>;
+    rowCheckboxDisabled?: RowCheckboxDisabled<RowType>;
+    rowGetStates?: (p: RowGetStatesProps<RowType, RowIdType>) => RowGetStatesReturnType<RowType, RowIdType> | null;
+    groupedRow?: {
+        getStates: (p: {
+            checkedCalculated: boolean;
+            indeterminateCalculated: boolean;
+            row: GroupRow<RowType>;
+            selectedRows: ReadonlySet<string | number>;
+            selectedChildCount: number;
+            childCount: number;
+        }) => {
+            checked?: boolean | null;
+            indeterminate?: boolean | null;
+            showCheckbox?: boolean | null;
+            checkboxDisabled?: boolean | null;
+        } | null;
+        onChange?: (p: {
+            row: GroupRow<RowType>;
+            setSelectedRows: React.Dispatch<React.SetStateAction<ReadonlySet<string | number>>>;
+            checked: boolean;
+            indeterminate: boolean;
+            checkboxDisabled: boolean;
+            showCheckbox: boolean;
+            defaultSetter: () => void;
+        }) => void;
+    };
+};
+export type FlattenedRowsArrAndMap<RowType, RowIdType> = {
+    flattenedRows: (RowType & {
+        [SELECTING_KEYS.level]?: number;
+        [SELECTING_KEYS.parent]?: RowType | null;
+    })[];
+    flattenedRowsMap: Map<RowIdType, RowType & {
+        [SELECTING_KEYS.level]?: number;
+        [SELECTING_KEYS.parent]?: RowType | null;
+    }>;
+};

package/components/TableCanvas/feature-select-row/useCheckboxRowIndexes.d.ts

@@ -0,0 +1,16 @@
+interface UseCheckboxRowIndexesParams<RowType, RowIdType extends string | number> {
+    rows: readonly RowType[];
+    rowKeyGetter?: (row: RowType) => RowIdType;
+    selectedRows?: ReadonlySet<RowIdType>;
+    selectingRowConfig?: {
+        selectingRowsIsActive?: boolean;
+    };
+    flattenedRowsArrAndMap: unknown;
+    setSelectedRows: unknown;
+    isRowsGroupingActive: boolean;
+}
+export declare function useCheckboxRowIndexes<RowType, RowIdType extends string | number>({ rows, rowKeyGetter, selectedRows, selectingRowConfig, flattenedRowsArrAndMap, setSelectedRows, isRowsGroupingActive }: UseCheckboxRowIndexesParams<RowType, RowIdType>): {
+    checkboxSelectedRowIndexes: Set<number> | undefined;
+    checkboxVisibleRowIndexes: Set<number> | undefined;
+};
+export {};

package/components/TableCanvas/feature-select-row/useSelectRow.d.ts

@@ -0,0 +1,94 @@
+import { FlattenedRowsArrAndMap } from './types';
+import { ObjectForExtending, Prettify } from '../types/utils.type';
+import { TableConfig } from '../types/table-config.type';
+
+export interface Props {
+    direction: 'ltr' | 'rtl';
+}
+export declare function useSelectRow<FilterStateType extends ObjectForExtending, RowIdType extends string | number, RowType extends ObjectForExtending, SummaryRowType = unknown>({ tableConfig, rows }: {
+    rows: RowType[];
+    tableConfig?: Prettify<TableConfig<RowType, SummaryRowType, RowIdType, FilterStateType>>;
+}): {
+    selectingRowsIsActive: boolean;
+    setSelectingRowsIsActive: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    selectedRows: ReadonlySet<RowIdType> | undefined;
+    setSelectedRows: import('react').Dispatch<import('react').SetStateAction<ReadonlySet<RowIdType>>> | undefined;
+    selectingRowConfig: {
+        rowKeyGetter?: ((row: RowType) => RowIdType) | undefined;
+        showDefault?: boolean | undefined;
+        showState?: [boolean, import('react').Dispatch<import('react').SetStateAction<boolean>>] | undefined;
+        showInControl?: boolean | undefined;
+        disableSummaryCheckboxInHeader?: boolean | undefined;
+        hideSummaryCheckboxInHeader?: boolean | undefined;
+        hideSummaryCheckbox?: boolean | undefined;
+        summaryChecked?: {
+            checked: boolean | import('./types').SummaryCheckedFunc<RowType, boolean, void, string | number>;
+            indeterminate: boolean | import('./types').SummaryCheckedFunc<RowType, boolean, {
+                checkedAll: boolean;
+            }, string | number>;
+            getCountOfChecked: import('./types').SummaryCheckedFunc<RowType, number, void, string | number>;
+            onChange: import('./types').SummaryCheckedFunc<RowType, void, {
+                checkedAll: boolean;
+                clearButtonClicked?: boolean | undefined;
+                setSelectedRowsIds: import('react').Dispatch<import('react').SetStateAction<ReadonlySet<string | number>>>;
+            }, string | number>;
+        } | undefined;
+        summaryCheckedUncontrolled?: {
+            onChange: (event: import('react').ChangeEvent<HTMLInputElement>) => void;
+        } | undefined;
+        rowShowCheckbox?: import('./types').RowShowCheckbox<RowType> | undefined;
+        rowCheckboxDisabled?: import('./types').RowCheckboxDisabled<RowType> | undefined;
+        rowGetStates?: ((p: import('./types').RowGetStatesProps<RowType, RowIdType>) => import('./types').RowGetStatesReturnType<RowType, RowIdType> | null) | undefined;
+        groupedRow?: {
+            getStates: (p: {
+                checkedCalculated: boolean;
+                indeterminateCalculated: boolean;
+                row: import('..').GroupRow<RowType>;
+                selectedRows: ReadonlySet<string | number>;
+                selectedChildCount: number;
+                childCount: number;
+            }) => {
+                checked?: boolean | null | undefined;
+                indeterminate?: boolean | null | undefined;
+                showCheckbox?: boolean | null | undefined;
+                checkboxDisabled?: boolean | null | undefined;
+            } | null;
+            onChange?: ((p: {
+                row: import('..').GroupRow<RowType>;
+                setSelectedRows: import('react').Dispatch<import('react').SetStateAction<ReadonlySet<string | number>>>;
+                checked: boolean;
+                indeterminate: boolean;
+                checkboxDisabled: boolean;
+                showCheckbox: boolean;
+                defaultSetter: () => void;
+            }) => void) | undefined;
+        } | undefined;
+        controlBlock?: {
+            domMetadata?: import('../types/additional.type').DomMetadata | undefined;
+        } | undefined;
+        sidebar?: {
+            domMetadata?: import('../types/additional.type').DomMetadata | undefined;
+        } | undefined;
+        selectingRules: {
+            levels: number | "all" | number[] | ((lvl: number) => boolean);
+        };
+        selectingRowsIsActive: boolean;
+    };
+    flattenedRowsArrAndMap: FlattenedRowsArrAndMap<RowType, RowIdType> | null;
+    isSelectingRowLabelVisible: boolean;
+    setIsSelectingRowLabelVisible: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    isSelectingRowCounterVisible: boolean;
+    setIsSelectingRowCounterVisible: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    controlBlock: {
+        domMetadata: {
+            className: string | undefined;
+            dataAttributes: import('../types/utils.type').DataAttributes | undefined;
+        };
+    };
+    sidebar: {
+        domMetadata: {
+            className: string | undefined;
+            dataAttributes: import('../types/utils.type').DataAttributes | undefined;
+        };
+    };
+};

package/components/TableCanvas/feature-sorting/header-sort-button.d.ts

@@ -0,0 +1,12 @@
+import { SortColumn } from './types';
+import { CanvasEl } from '../TableGlideInstance';
+import { default as React } from 'react';
+
+type HeaderSortButtonProps = {
+    columnKey: string;
+    columnSorted: SortColumn | undefined;
+    setSortState: React.Dispatch<React.SetStateAction<readonly SortColumn[]>>;
+    accentColor: string;
+};
+export declare const renderHeaderSortButton: ({ columnKey, columnSorted, setSortState, accentColor }: HeaderSortButtonProps) => CanvasEl;
+export {};

package/components/TableCanvas/feature-sorting/index.cjs

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

package/components/TableCanvas/feature-sorting/index.d.ts

@@ -0,0 +1,2 @@
+export { renderHeaderSortButton } from './header-sort-button';
+export { useSortedRows } from './useSortedRows';

package/components/TableCanvas/feature-sorting/index.mjs

@@ -0,0 +1,5 @@
+import { b_ as o, b$ as t } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  o as renderHeaderSortButton,
+  t as useSortedRows
+};

package/components/TableCanvas/feature-sorting/sort-handlers.d.ts

@@ -0,0 +1,5 @@
+import { ObjectForExtending } from '../types';
+
+export declare const isBlank: (v: unknown) => boolean;
+export declare const stringComparator: <RowType extends ObjectForExtending>(sortKey: keyof RowType) => (a: RowType, b: RowType) => number;
+export declare const numberComparator: <RowType extends ObjectForExtending>(sortKey: keyof RowType) => (a: RowType, b: RowType) => number;

package/components/TableCanvas/feature-sorting/styles.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="react" />
+export declare const StyledSortIconButton: import('styled-components').StyledComponent<import('react').FunctionComponent<import('@salutejs/plasma-new-hope/types/engines/types.js').PropsType<{
+    view: {
+        default: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        accent: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        secondary: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        clear: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        positive: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        warning: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        negative: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        dark: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        black: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        white: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+    };
+    size: {
+        s: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        xs: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        xxs: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+    };
+    disabled: {
+        true: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+    };
+    focused: {
+        true: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+    };
+}> & ((Omit<import('react').ButtonHTMLAttributes<HTMLElement>, "value"> & import('@salutejs/plasma-new-hope').AsProps<any> & {
+    text?: string | undefined;
+    contentLeft?: import('react').ReactNode;
+    contentPlacing?: "default" | "relaxed" | undefined;
+    additionalContent?: import('react').ReactNode;
+    isLoading?: boolean | undefined;
+    loader?: import('react').ReactNode;
+    stretch?: boolean | undefined;
+    stretching?: "fixed" | "auto" | "filled" | undefined;
+    square?: boolean | undefined;
+    focused?: boolean | undefined;
+    disabled?: boolean | undefined;
+    pin?: "square-square" | "square-clear" | "clear-square" | "clear-clear" | "clear-circle" | "circle-clear" | "circle-circle" | undefined;
+    appearance?: "default" | "outline" | undefined;
+    view?: string | undefined;
+    size?: string | undefined;
+    outlined?: boolean | undefined;
+    shiftLeft?: boolean | undefined;
+    shiftRight?: boolean | undefined;
+    blur?: "small" | "medium" | "large" | undefined;
+} & {
+    value?: string | number | undefined;
+    contentRight?: undefined;
+} & import('react').RefAttributes<HTMLButtonElement>) | (Omit<import('react').ButtonHTMLAttributes<HTMLElement>, "value"> & import('@salutejs/plasma-new-hope').AsProps<any> & {
+    text?: string | undefined;
+    contentLeft?: import('react').ReactNode;
+    contentPlacing?: "default" | "relaxed" | undefined;
+    additionalContent?: import('react').ReactNode;
+    isLoading?: boolean | undefined;
+    loader?: import('react').ReactNode;
+    stretch?: boolean | undefined;
+    stretching?: "fixed" | "auto" | "filled" | undefined;
+    square?: boolean | undefined;
+    focused?: boolean | undefined;
+    disabled?: boolean | undefined;
+    pin?: "square-square" | "square-clear" | "clear-square" | "clear-clear" | "clear-circle" | "circle-clear" | "circle-circle" | undefined;
+    appearance?: "default" | "outline" | undefined;
+    view?: string | undefined;
+    size?: string | undefined;
+    outlined?: boolean | undefined;
+    shiftLeft?: boolean | undefined;
+    shiftRight?: boolean | undefined;
+    blur?: "small" | "medium" | "large" | undefined;
+} & {
+    value?: undefined;
+    contentRight?: import('react').ReactNode;
+} & import('react').RefAttributes<HTMLButtonElement>))>, import('styled-components').DefaultTheme, {}, never>;

package/components/TableCanvas/feature-sorting/types.d.ts

@@ -0,0 +1,5 @@
+export type SortDirection = 'ASC' | 'DESC';
+export interface SortColumn {
+    readonly columnKey: string;
+    readonly direction: SortDirection;
+}

package/components/TableCanvas/feature-sorting/useSortedRows.d.ts

@@ -0,0 +1,15 @@
+import { ColumnConfig, ObjectForExtending, TableConfig } from '../types';
+
+export declare const useSortedRows: <RowType extends ObjectForExtending, SummaryRowType, FilterStateType extends ObjectForExtending, RowIdType extends string | number>({ rows, columns, tableConfig, infinityScrollActiveInConfig, paginationActiveInConfig }: {
+    rows: RowType[];
+    columns: readonly ColumnConfig<RowType, SummaryRowType>[];
+    tableConfig: TableConfig<RowType, SummaryRowType, RowIdType, FilterStateType>;
+    infinityScrollActiveInConfig: boolean;
+    paginationActiveInConfig: boolean;
+}) => {
+    sortColumns: readonly import('./types').SortColumn[] | undefined;
+    setSortColumns: import('react').Dispatch<import('react').SetStateAction<readonly import('./types').SortColumn[]>> | undefined;
+    sortedRows: readonly RowType[];
+    sortIsVisible: boolean;
+    setSortIsVisible: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+};

package/components/TableCanvas/feature-table-settings/TableFeatureBlock.d.ts

@@ -0,0 +1,6 @@
+import { FeatureItem } from '../widgets/control-block/types';
+import { default as React } from 'react';
+
+export declare const FeaturesSidebarBlock: React.FC<{
+    features: FeatureItem[];
+}>;

package/components/TableCanvas/feature-table-settings/TableSettingsBlock.d.ts

@@ -0,0 +1,8 @@
+import { FeatureItem } from '../widgets/control-block/types';
+import { default as React, FC } from 'react';
+
+export declare const TableSettingsBlock: FC<{
+    defaultSettings?: FeatureItem[];
+    features?: FeatureItem[];
+    customGeneralSettingsSlot?: React.ReactNode;
+}>;

package/components/TableCanvas/feature-table-settings/TableSettingsWithTabs.d.ts

@@ -0,0 +1,17 @@
+import { FeatureItem } from '../widgets/control-block/types';
+import { DomMetadata } from '../types/additional.type';
+import { default as React, FC, ReactNode } from 'react';
+
+export declare const TableSettingsWithTabs: FC<{
+    generalSettings?: FeatureItem[];
+    customFeatures?: FeatureItem[];
+    filteringContent?: ReactNode;
+    columnsContent?: ReactNode;
+    showFiltering: boolean;
+    showColumns: boolean;
+    filteringDomMetadata?: DomMetadata;
+    columnsDomMetadata?: DomMetadata;
+    customGeneralSettingsSlot?: ReactNode;
+    activeSettingsTabId: string | null;
+    setActiveSettingsTabId: React.Dispatch<React.SetStateAction<string | null>>;
+}>;

package/components/TableCanvas/feature-table-settings/index.cjs

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

package/components/TableCanvas/feature-table-settings/index.d.ts

@@ -0,0 +1,2 @@
+export { TableSettingsBlock } from './TableSettingsBlock';
+export { TableSettingsWithTabs } from './TableSettingsWithTabs';

package/components/TableCanvas/feature-table-settings/index.mjs

@@ -0,0 +1,5 @@
+import { c$ as e, d0 as s } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  e as TableSettingsBlock,
+  s as TableSettingsWithTabs
+};