@daisforge/ui 1.10.3

package/components/TableCanvas/TableGlideInstance/type.d.ts

@@ -0,0 +1,164 @@
+import { ObjectForExtending } from '../types/utils.type';
+import { CtxsType } from '../types/ctxs.type';
+import { TableContentStateOverlay } from '../feature-content-state/types';
+import { FillMeta, RowsChangeType } from '../feature-cell-transfer/types';
+import { ReactNode } from 'react';
+import { CanvasContent, CanvasEl, CanvasEvent, CanvasNodeTooltipConfig, CellActiveState, CellContent, CellHoverState, CellInfo, CellsSelectionMode, CellThemeOverrideResult, DataEditorRef, HeaderCellInfo as HeaderCellInfoGlide, HighlightActiveType, HoverEffectsConfig, Justify, SummaryCellInfo, TableGlideCustomProps, TableGlideProps, Theme } from '../../TableGlide';
+import { DropdownProps } from '../../Dropdown';
+import { CellActivatedEventArgs } from '@glideappsfinal/glide-data-grid';
+
+export type { TextCellEntry as TextCellEntryType } from '@glideappsfinal/glide-data-grid';
+export type { ActiveTheme, CanvasBadgeProps, CanvasButtonProps, CanvasContainerProps, CanvasEmbedIconButtonProps, CanvasIconButtonProps, CanvasIconProps, CanvasTextProps, ProvideEditorCallback, ProvideEditorCallbackResult, ProvideEditorComponent, SIZE as SIZE_GLIDE_INSTANCE, TableGlideSizeConfig } from '../../TableGlide';
+export type { CanvasContent, CanvasEl, CanvasEvent, CellActiveState, CellContent, CellHoverState, CellsSelectionMode, CellThemeOverrideResult, DataEditorRef, HighlightActiveType, HoverEffectsConfig, Justify, TableGlideCustomProps };
+export interface RowsChangeDataGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> {
+    indexes: number[];
+    column: ColumnGlideInstance<R, SR, CustomCtxs>;
+    type: RowsChangeType;
+    fillMeta?: FillMeta;
+    fillResult?: string[][];
+}
+export type HeaderCellInfoGlideInstance<R extends ObjectForExtending, SR, CustomCtxs extends ObjectForExtending = {}> = Omit<HeaderCellInfoGlide<R, SR>, 'column' | 'ctxs'> & {
+    column: ColumnGlideInstance<R, SR, CustomCtxs>;
+    ctxs: CtxsType<CustomCtxs>;
+};
+export type CellInfoGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = Omit<CellInfo<R, SR>, 'column' | 'ctxs'> & {
+    column: ColumnGlideInstance<R, SR, CustomCtxs>;
+    ctxs: CtxsType<CustomCtxs>;
+};
+export type EditingCellInfoGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = Omit<CellInfoGlideInstance<R, SR, CustomCtxs>, 'hovered' | 'active'> & {
+    onRowChange: (newV: R, closeEditor?: boolean) => void;
+    initialValue: string | undefined;
+    portalElementRef: React.RefObject<HTMLElement> | undefined;
+    activation: CellActivatedEventArgs | undefined;
+    cellWidth: number;
+    cellHeight: number;
+    readOnly: boolean | undefined;
+};
+export type PreviewCellInfoGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = Omit<EditingCellInfoGlideInstance<R, SR, CustomCtxs>, 'onRowChange'>;
+export type SummaryCellInfoGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = Omit<SummaryCellInfo<R, SR>, 'column' | 'ctxs'> & {
+    column: ColumnGlideInstance<R, SR, CustomCtxs>;
+    ctxs: CtxsType<CustomCtxs>;
+};
+export type ColumnGlideInstance<R extends ObjectForExtending, SR, CustomCtxs extends ObjectForExtending = {}> = {
+    key: string;
+    name: string | CanvasEl;
+    nameAsString?: string;
+    readonly width?: number;
+    isServiceColumn?: boolean;
+    isErrorCell?: (row: R) => boolean;
+    frozen?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    maxAutoWidth?: number;
+    renderHeaderCell?: (cellInfo: HeaderCellInfoGlideInstance<R, SR, CustomCtxs>) => CanvasContent;
+    renderCell?: (cellInfo: CellInfoGlideInstance<R, SR, CustomCtxs>) => CellContent;
+    contentAlign?: 'left' | 'right' | 'center';
+    copyData?: string | ((row: R) => string);
+    editable?: boolean | ((row: R) => boolean);
+    renderEditCell?: (cellInfo: EditingCellInfoGlideInstance<R, SR, CustomCtxs>) => ReactNode;
+    renderCellPreview?: 'none' | 'cellEditorAsPreview' | ((cellInfo: PreviewCellInfoGlideInstance<R, SR, CustomCtxs>) => ReactNode);
+    renderSummaryCell?: (cellInfo: SummaryCellInfoGlideInstance<R, SR, CustomCtxs>) => CellContent;
+    colSpan?: number | ((cellInfo: CellInfoGlideInstance<R, SR, CustomCtxs>) => number);
+    cellTooltip?: CanvasNodeTooltipConfig | ((context: {
+        row: R;
+        column: ColumnGlideInstance<R, SR, CustomCtxs>;
+        ctxs: CtxsType<CustomCtxs>;
+        refTable?: React.Ref<DataEditorRef>;
+        colInd?: number;
+        rowInd?: number;
+        theme?: Theme;
+    }) => CanvasNodeTooltipConfig | null);
+    headerCellTooltip?: CanvasNodeTooltipConfig | ((context: {
+        column: ColumnGlideInstance<R, SR, CustomCtxs>;
+        ctxs: CtxsType<CustomCtxs>;
+        refTable?: React.Ref<DataEditorRef>;
+        colInd?: number;
+        theme?: Theme;
+    }) => CanvasNodeTooltipConfig | null);
+    columnThemeOverride?: (cellInfo: CellInfoGlideInstance<R, SR, CustomCtxs>) => CellThemeOverrideResult | undefined;
+};
+export type ColumnOrColumnGroupGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = ColumnGlideInstance<R, SR, CustomCtxs> | ColumnGroupGlideInstance<R, SR, CustomCtxs>;
+export type ColumnGroupGlideInstance<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = {
+    readonly key: string;
+    readonly name: CanvasEl;
+    readonly children: readonly ColumnOrColumnGroupGlideInstance<R, SR, CustomCtxs>[];
+};
+export type TableInfoBase<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = {
+    column: ColumnOrColumnGroupGlideInstance<R, SR, CustomCtxs>;
+    ctxs: CustomCtxs;
+    refTable?: React.Ref<DataEditorRef>;
+};
+export type TableInfoWithRow<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = TableInfoBase<R, SR, CustomCtxs> & {
+    row: R;
+};
+export type TableGlideInstanceContextMenu<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = {
+    onHeaderContextMenu?: (...args: [
+        ...Parameters<NonNullable<TableGlideProps<R, SR>['onHeaderContextMenu']>>,
+        TableInfoBase<R, SR, CustomCtxs>
+    ]) => void;
+    onCellContextMenu?: (...args: [
+        ...Parameters<NonNullable<TableGlideProps<R, SR>['onCellContextMenu']>>,
+        TableInfoWithRow<R, SR, CustomCtxs>
+    ]) => void;
+};
+export type CellReadOnlyEditorGlideInstanceStaticProps = {
+    formatOptions: ContentFormat | undefined;
+    disableLeftOffset: boolean | undefined;
+    contentAlign: 'right' | 'left' | 'center';
+};
+export type CellReadOnlyEditorGlideInstanceProps<R extends ObjectForExtending, SR> = EditingCellInfoGlideInstance<R, SR> & CellReadOnlyEditorGlideInstanceStaticProps;
+export type TableGlideInstanceProps<R extends ObjectForExtending, SR = unknown, CustomCtxs extends ObjectForExtending = {}> = Omit<TableGlideProps<R, SR>, 'columns' | 'onHeaderContextMenu' | 'onCellContextMenu'> & {
+    columns: readonly ColumnGlideInstance<R, SR, CustomCtxs>[];
+    onHeaderContextMenuDropdown?: HeaderContextMenuDropdownProps<R, SR, CustomCtxs>;
+    onCellContextMenuDropdown?: CellContextMenuDropdownProps<R, SR>;
+    containerProps?: {
+        className?: string;
+        style?: React.CSSProperties;
+        ref?: React.Ref<HTMLDivElement>;
+    };
+    contentStateOverlay?: TableContentStateOverlay;
+    renderOverlayFeatures?: (ctx: {
+        containerElement: HTMLDivElement;
+        renderInContainer: (children: React.ReactNode) => React.ReactPortal | null;
+    }) => React.ReactNode;
+    CellReadOnlyEditor: (props: CellReadOnlyEditorGlideInstanceProps<R, SR>) => ReactNode;
+    onRowsChange?: (rows: R[], data: RowsChangeDataGlideInstance<R, SR, CustomCtxs>) => void;
+    onCellClicked?: (cell: readonly [number, number], info: TableInfoWithRow<R, SR, CustomCtxs>) => void;
+} & TableGlideInstanceContextMenu<R, SR, CustomCtxs>;
+export type CommonFormat = {
+    alignContent?: 'right' | 'left' | 'center';
+};
+export type CustomFormat = CommonFormat & {
+    customFormat: (value: string) => React.ReactNode;
+};
+export type NumberFormatOptions = CommonFormat & {
+    type: 'number';
+    decimalSeparator?: string;
+    thousandSeparator?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    useGrouping?: boolean;
+    locales?: string | string[];
+    alignContent?: 'right' | 'left' | 'center';
+};
+export type ContentFormat = 'number' | CustomFormat | NumberFormatOptions;
+export type ContextMenuDropdownItem = NonNullable<DropdownProps['items']>[number];
+export type ContextMenuDropdownProps = Omit<DropdownProps, 'children' | 'items' | 'placement' | 'closeOnOverlayClick' | 'portal' | 'openByRightClick' | 'onItemClick' | 'hoverIndex' | 'alwaysOpened' | 'trigger' | 'hasArrow' | 'onItemSelect'>;
+export type DropdownContextMenu = {
+    type: 'Dropdown';
+    getDropdownItems: (params: {
+        columnLabel: string;
+    }) => DropdownProps['items'];
+} & ContextMenuDropdownProps;
+export type CellContextMenuDropdownProps<RowType extends ObjectForExtending, SummaryRowType, CustomCtxs extends ObjectForExtending = ObjectForExtending> = ContextMenuDropdownProps & {
+    type: 'dropdown';
+    getDropdownItems: (params: TableInfoWithRow<RowType, SummaryRowType, CustomCtxs>) => DropdownProps['items'];
+    onOpen?: (params: TableInfoWithRow<RowType, SummaryRowType, CustomCtxs>) => void;
+    onItemSelect?: (item: ContextMenuDropdownItem, context: TableInfoWithRow<RowType, SummaryRowType, CustomCtxs>, event?: React.SyntheticEvent) => void;
+};
+export type HeaderContextMenuDropdownProps<RowType extends ObjectForExtending, SummaryRowType = unknown, CustomCtxs extends ObjectForExtending = ObjectForExtending> = ContextMenuDropdownProps & {
+    type: 'dropdown';
+    getDropdownItems: (params: TableInfoBase<RowType, SummaryRowType, CustomCtxs>) => DropdownProps['items'];
+    onOpen?: (params: TableInfoBase<RowType, SummaryRowType, CustomCtxs>) => void;
+    onItemSelect?: (item: ContextMenuDropdownItem, context: TableInfoBase<RowType, SummaryRowType, CustomCtxs>, event?: React.SyntheticEvent) => void;
+};

package/components/TableCanvas/TableGlideInstance/typeGuards.d.ts

@@ -0,0 +1,5 @@
+import { ColumnGlideInstance, ColumnGroupGlideInstance, ColumnOrColumnGroupGlideInstance } from './type';
+import { ObjectForExtending } from '../types/utils.type';
+
+export declare function isNotGroup<R extends ObjectForExtending, SR>(column: ColumnOrColumnGroupGlideInstance<R, SR>): column is ColumnGlideInstance<R, SR>;
+export declare function isGroupColumn<R extends ObjectForExtending, SR>(column: ColumnOrColumnGroupGlideInstance<R, SR>): column is ColumnGroupGlideInstance<R, SR>;

package/components/TableCanvas/TableGlideInstance/utils/column/getColumnName.d.ts

@@ -0,0 +1,5 @@
+export declare const getColumnName: ({ name, nameAsString, fallback }: {
+    name: string | unknown;
+    nameAsString?: string;
+    fallback: string;
+}) => string;

package/components/TableCanvas/TableGlideInstance/utils/column/index.cjs

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

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

@@ -0,0 +1 @@
+export { getColumnName } from './getColumnName';

package/components/TableCanvas/TableGlideInstance/utils/column/index.mjs

@@ -0,0 +1,4 @@
+import { g as o } from "../../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  o as getColumnName
+};

package/components/TableCanvas/TableGlideInstance/utils/convertToCellContent.d.ts

@@ -0,0 +1,3 @@
+import { CellContent } from '../type';
+
+export declare const convertToCellContent: (value: unknown) => CellContent;

package/components/TableCanvas/TableGlideInstance/utils/index.cjs

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

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

@@ -0,0 +1,2 @@
+export * from './column';
+export { convertToCellContent } from './convertToCellContent';

package/components/TableCanvas/TableGlideInstance/utils/index.mjs

@@ -0,0 +1,5 @@
+import { e as t, g as n } from "../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  t as convertToCellContent,
+  n as getColumnName
+};

package/components/TableCanvas/components/AnimatedCounter.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+export declare const AnimatedCounter: 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;
+        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;
+        light: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+    };
+    size: {
+        l: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        m: import('@salutejs/plasma-new-hope/types/engines/types.js').PolymorphicClassName;
+        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;
+    };
+}> & import('react').HTMLAttributes<HTMLDivElement> & import('@salutejs/plasma-new-hope/types/components/Counter/Counter.types.js').CustomCounterProps & import('react').RefAttributes<HTMLDivElement>>, import('styled-components').DefaultTheme, {}, never>;

package/components/TableCanvas/components/SplitIconButton/SplitIconButton.d.ts

@@ -0,0 +1,3 @@
+import { SplitIconButtonProps } from './SplitIconButton.types';
+
+export declare const SplitIconButton: ({ icon, onIconClick, iconTooltip, chevronIcon, chevronSize, size, items, onItemSelect, onChevronClick, onToggle, dropdownProps, domMetadata, iconDomMetadata, chevronDomMetadata }: SplitIconButtonProps) => import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/components/SplitIconButton/SplitIconButton.styled.d.ts

@@ -0,0 +1,5 @@
+export declare const Root: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const IconSlot: import('styled-components').StyledComponent<"span", import('styled-components').DefaultTheme, {
+    $flippable?: boolean | undefined;
+    $open?: boolean | undefined;
+}, never>;

package/components/TableCanvas/components/SplitIconButton/SplitIconButton.types.d.ts

@@ -0,0 +1,21 @@
+import { TableDropdownConfigProps, TableDropdownProps } from '../TableDropdown/types';
+import { DataAttributes } from '../../types/utils.type';
+import { ComponentProps, ReactNode } from 'react';
+import { EmbedIconButton } from '../../../EmbedIconButton';
+
+export type SplitIconButtonProps = {
+    icon: ReactNode;
+    onIconClick?: () => void;
+    iconTooltip?: ReactNode;
+    chevronIcon?: ReactNode;
+    chevronSize?: 'xs' | 's' | 'm';
+    size?: ComponentProps<typeof EmbedIconButton>['size'];
+    items?: TableDropdownProps['items'];
+    onItemSelect?: TableDropdownProps['onItemSelect'];
+    onChevronClick?: () => void;
+    onToggle?: (isOpen: boolean) => void;
+    dropdownProps?: TableDropdownConfigProps;
+    domMetadata?: DataAttributes;
+    iconDomMetadata?: DataAttributes;
+    chevronDomMetadata?: DataAttributes;
+};

package/components/TableCanvas/components/SplitIconButton/index.cjs

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

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

@@ -0,0 +1,2 @@
+export { SplitIconButton } from './SplitIconButton';
+export type { SplitIconButtonProps } from './SplitIconButton.types';

package/components/TableCanvas/components/SplitIconButton/index.mjs

@@ -0,0 +1,4 @@
+import { Q as n } from "../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  n as SplitIconButton
+};

package/components/TableCanvas/components/TableDropdown/TableDropdown.d.ts

@@ -0,0 +1,11 @@
+import { TableDropdownProps } from './types';
+import { DropdownItemOption } from '../../../Dropdown';
+
+export declare const TableDropdown: (props: TableDropdownProps & {
+    isOpen?: boolean;
+    shouldCloseOnItemSelect?: (item: DropdownItemOption) => boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const TableDropdownWithCustomClickOutside: ({ onClose, isOpen, portal, ...props }: TableDropdownProps & {
+    isOpen?: boolean;
+    onClose?: () => void;
+}) => import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/components/TableDropdown/index.cjs

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

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

@@ -0,0 +1 @@
+export { TableDropdown, TableDropdownWithCustomClickOutside } from './TableDropdown';

package/components/TableCanvas/components/TableDropdown/index.mjs

@@ -0,0 +1,5 @@
+import { U as e, V as r } from "../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  e as TableDropdown,
+  r as TableDropdownWithCustomClickOutside
+};

package/components/TableCanvas/components/TableDropdown/types.d.ts

@@ -0,0 +1,7 @@
+import { CSSObject } from 'styled-components';
+import { DropdownProps } from '../../../Dropdown';
+
+export type TableDropdownProps = DropdownProps & {
+    $css?: CSSObject;
+};
+export type TableDropdownConfigProps = Omit<TableDropdownProps, 'onItemSelect' | 'items' | 'onToggle' | 'size' | 'portal'>;

package/components/TableCanvas/components/TableTooltip.d.ts

@@ -0,0 +1,7 @@
+import { TooltipProps } from '../../Tooltip';
+
+interface TableTooltipProps extends Omit<TooltipProps, 'frame' | 'usePortal'> {
+    children?: React.ReactNode;
+}
+export declare const TableTooltip: ({ children, ...props }: TableTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/components/TableCanvas/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const TABLE_BUBBLES: {
+    readonly recalculateWidth: "Table::recalculateWidth";
+};
+export declare const TABLE_TOOLTIP_MOUSE_ENTER_DELAY = 750;
+export declare const DEFAULT_MAX_COLUMN_WIDTH = 700;
+export declare const DEFAULT_MIN_COLUMN_WIDTH = 24;
+export declare const INITIAL_WIDTH_RATIO = 0.7;

package/components/TableCanvas/contexts.d.ts

@@ -0,0 +1,118 @@
+import { DomMetadata } from './types/additional.type';
+import { SearchingProps } from './feature-searching/types';
+import { ContextMenuDropdownItem, ContextMenuDropdownProps } from './feature-context-menu/types';
+import { DropdownProps } from '../Dropdown';
+import { default as React, PropsWithChildren } from 'react';
+import { ActiveViewModsType, ColumnGroupConfig, ObjectForExtending, SortColumn } from './types';
+import { DataEditorRef, TableGlideInstanceProps } from './TableGlideInstance/type';
+import { SIZE } from './styles/styles.constants';
+
+type RowContextV = {
+    rowSize: SIZE;
+};
+export declare const useRowContext: <CustomType extends void | ObjectForExtending = undefined>() => CustomType extends ObjectForExtending ? CustomType & RowContextV : RowContextV;
+export type ExpandedRowsContextV = Set<string | number>;
+export type ExpandedRowsChangeContextV = React.Dispatch<React.SetStateAction<ExpandedRowsContextV>>;
+export declare const useExpandedRowsContext: () => {
+    expandedRowsIds: ExpandedRowsContextV | null;
+    setExpandedRowsIds: ExpandedRowsChangeContextV | null;
+};
+export type HeaderContextValueTypeInstance<FilterStateType extends Record<string | number, unknown>> = {
+    filters: FilterStateType | undefined;
+    setFilters: React.Dispatch<React.SetStateAction<FilterStateType>> | undefined;
+    clearedFiltersValue: FilterStateType | undefined;
+    sortState: readonly SortColumn[] | undefined;
+    setSortState: React.Dispatch<React.SetStateAction<readonly SortColumn[]>> | undefined;
+    sortIsVisible: boolean;
+    setSortIsVisible: React.Dispatch<React.SetStateAction<boolean>>;
+    rowSize: SIZE;
+    setRowSize: React.Dispatch<React.SetStateAction<SIZE>>;
+    onRowSizeChange?: (size: SIZE) => void;
+    isExpandedAllRows: boolean;
+    toggleExpandAllButton: () => void;
+    activeView: ActiveViewModsType;
+    setActiveView: React.Dispatch<React.SetStateAction<ActiveViewModsType>>;
+};
+export declare const HeaderContext: React.Context<HeaderContextValueTypeInstance<ObjectForExtending>>;
+export declare const useHeaderContext: <CustomType extends void | ObjectForExtending = undefined>() => CustomType extends ObjectForExtending ? CustomType & HeaderContextValueTypeInstance<ObjectForExtending> : HeaderContextValueTypeInstance<ObjectForExtending>;
+type CommonContextMenuProps = {
+    isOpen: boolean;
+    items: DropdownProps['items'] | null;
+    position: {
+        x: number;
+        y: number;
+    } | null;
+    open: (params: {
+        position: {
+            x: number;
+            y: number;
+        };
+        items?: DropdownProps['items'] | null;
+    }) => void;
+    close: () => void;
+};
+export type ContextMenuContextV<RowType extends ObjectForExtending, SummaryRowType = unknown> = CommonContextMenuProps & ContextMenuDropdownProps & {
+    enableHeaderContextMenu: boolean;
+    enableCellContextMenu: boolean;
+    openHeaderContextMenu: TableGlideInstanceProps<RowType, SummaryRowType>['onHeaderContextMenu'];
+    onItemSelect?: (item: ContextMenuDropdownItem, event?: React.SyntheticEvent) => void;
+    openCellContextMenu: TableGlideInstanceProps<RowType, SummaryRowType>['onCellContextMenu'];
+};
+export declare const useContextMenu: () => ContextMenuContextV<any, any>;
+type SearchContextValue = SearchingProps & {
+    searchQuery: string;
+    setSearchQuery: React.Dispatch<React.SetStateAction<string>>;
+    clearSearch: () => void;
+    internalLocalValue: string;
+    setInternalLocalValue: React.Dispatch<React.SetStateAction<string>>;
+    domMetadata?: DomMetadata;
+    searchOnType?: boolean;
+};
+export declare const useSearchContext: () => SearchContextValue;
+export type SidebarContextValue = {
+    isOpen: boolean;
+    width: number;
+    toggle: () => void;
+    setWidth: (width: number) => void;
+};
+export declare const useSidebar: () => SidebarContextValue;
+export type TableCollapseContextValue = {
+    isCollapsed: boolean;
+    toggleCollapse: () => void;
+    collapseText: string;
+    expandText: string;
+    enableCollapse: boolean;
+    domMetadata?: DomMetadata;
+    collapseButtonPlacement?: 'inside' | 'above';
+    collapseButtonAboveRightSlot?: React.ReactNode;
+    titleText?: string;
+    titleRender?: React.ReactNode;
+};
+export declare const useTableCollapse: () => TableCollapseContextValue;
+export declare const ContextProviders: <RowType extends ObjectForExtending, SummaryRowType = unknown>({ children, headerCtxV, rowCtxV, expandedRowCtxV, searchCtxV, contextMenuCtxV, sideBarCtxV, tableCollapseCtxV }: PropsWithChildren & {
+    headerCtxV: HeaderContextValueTypeInstance<ObjectForExtending>;
+    rowCtxV: RowContextV;
+    expandedRowCtxV: [ExpandedRowsContextV, ExpandedRowsChangeContextV];
+    searchCtxV: SearchContextValue;
+    contextMenuCtxV: ContextMenuContextV<RowType, SummaryRowType>;
+    sideBarCtxV: SidebarContextValue;
+    tableCollapseCtxV: TableCollapseContextValue;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const RefTableContext: React.Context<React.RefObject<DataEditorRef> | null>;
+export declare const useRefTableContext: () => React.RefObject<DataEditorRef> | null;
+export declare const RefTableGlobalContainerContext: React.Context<React.MutableRefObject<HTMLDivElement | null> | null>;
+export declare const useRefTableGlobalContainerContext: () => React.MutableRefObject<HTMLDivElement | null> | undefined;
+export declare const RefTableContainerContext: React.Context<React.MutableRefObject<HTMLDivElement | null> | null>;
+export declare const useRefTableContainerContext: () => React.MutableRefObject<HTMLDivElement | null> | undefined;
+export type AllGroupsMap = Map<string, ColumnGroupConfig<ObjectForExtending, unknown> | undefined | null>;
+export declare const ColumnGroupContext: React.Context<{
+    allGroupsMap: AllGroupsMap;
+    columnsGroupingIsActive: boolean;
+    maxLevelOfGroups: number;
+}>;
+export declare const useColumnGroupContext: () => {
+    allGroupsMap: AllGroupsMap;
+    columnsGroupingIsActive: boolean;
+    maxLevelOfGroups: number;
+};
+export { TableResizeObserverProvider, TableResizeObserverProviderWrapper, useTableResizeObserver, useTableResizeObserverWidth } from './resize-observer-context';

package/components/TableCanvas/data/hideServiceKeysHanlder.d.ts

@@ -0,0 +1,3 @@
+import { ObjectForExtending } from '../types/utils.type';
+
+export declare function hideRowServiceKeysHandler<Row extends ObjectForExtending>(r: Row): Row;

package/components/TableCanvas/feature-cell-transfer/hooks/useClipboard.d.ts

@@ -0,0 +1,30 @@
+import { CellTransferConfig, RowsChangeType, TransferColumnConfig } from '../types';
+import { ObjectForExtending } from '../../types/utils.type';
+import { TableNotification } from '../../feature-notifications';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+interface UseClipboardParams<R extends ObjectForExtending> {
+    editModeEnabled: boolean;
+    cellTransferConfig?: CellTransferConfig;
+    columns: readonly TransferColumnConfig[];
+    flattenedRows: readonly R[];
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    rowContextValue?: ObjectForExtending;
+    headerContextValue?: ObjectForExtending;
+    onRowsChange?: (rows: R[], data: {
+        indexes: number[];
+        column: TransferColumnConfig;
+        rows?: {
+            before: R;
+            after: R;
+        }[];
+        type: RowsChangeType;
+    }) => void;
+    onNotification?: (event: TableNotification) => void;
+}
+export declare function useClipboard<R extends ObjectForExtending>({ editModeEnabled, cellTransferConfig, columns, flattenedRows, containerRef, rowContextValue, headerContextValue, onRowsChange, onNotification }: UseClipboardParams<R>): {
+    onGridSelectionChange: (next: GridSelection) => void;
+    handleCopy: () => void;
+    handlePaste: (clipboardText?: string | undefined) => Promise<void>;
+};
+export {};

package/components/TableCanvas/feature-cell-transfer/hooks/useCopy.d.ts

@@ -0,0 +1,16 @@
+import { CellTransferConfig, TransferColumnConfig } from '../types';
+import { ObjectForExtending } from '../../types';
+import { TableNotification } from '../../feature-notifications';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+interface UseCopyParams<R extends ObjectForExtending> {
+    cellTransferConfig?: CellTransferConfig;
+    columns: readonly TransferColumnConfig[];
+    flattenedRows: readonly R[];
+    selectionRef: React.RefObject<GridSelection | null>;
+    onNotification?: (event: TableNotification) => void;
+}
+export declare function useCopy<R extends ObjectForExtending>({ cellTransferConfig, columns, flattenedRows, selectionRef, onNotification }: UseCopyParams<R>): {
+    handleCopy: () => void;
+};
+export {};

package/components/TableCanvas/feature-cell-transfer/hooks/useFillHandle.d.ts

@@ -0,0 +1,34 @@
+import { AllowedFillDirections, CellTransferConfig, FillHandleConfig, FillMeta, FillPatternEvent, RowsChangeType, TransferColumnConfig } from '../types';
+import { ObjectForExtending } from '../../types/utils.type';
+import { TableNotification } from '../../feature-notifications';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+interface UseFillHandleParams<R extends ObjectForExtending> {
+    editModeEnabled: boolean;
+    cellTransferConfig?: CellTransferConfig;
+    columns: readonly TransferColumnConfig[];
+    flattenedRows: readonly R[];
+    rowContextValue?: ObjectForExtending;
+    headerContextValue?: ObjectForExtending;
+    onRowsChange?: (rows: R[], data: {
+        indexes: number[];
+        column: TransferColumnConfig;
+        rows?: {
+            before: R;
+            after: R;
+        }[];
+        type: RowsChangeType;
+        fillMeta?: FillMeta;
+        fillResult?: string[][];
+    }) => void;
+    onNotification?: (event: TableNotification) => void;
+}
+export declare function useFillHandle<R extends ObjectForExtending>({ editModeEnabled, cellTransferConfig, columns, flattenedRows, rowContextValue, headerContextValue, onRowsChange, onNotification }: UseFillHandleParams<R>): {
+    fillHandleProps: {
+        fillHandle: boolean | Pick<FillHandleConfig, "size" | "shape" | "outline">;
+        allowedFillDirections: AllowedFillDirections;
+        onFillPattern: (event: FillPatternEvent) => void;
+    } | undefined;
+    onSelectionChangeForFill: (selection: GridSelection) => void;
+};
+export {};

package/components/TableCanvas/feature-cell-transfer/hooks/usePaste.d.ts

@@ -0,0 +1,28 @@
+import { CellTransferConfig, RowsChangeType, TransferColumnConfig } from '../types';
+import { ObjectForExtending } from '../../types';
+import { TableNotification } from '../../feature-notifications';
+import { GridSelection } from '@glideappsfinal/glide-data-grid';
+
+interface UsePasteParams<R extends ObjectForExtending> {
+    editModeEnabled: boolean;
+    cellTransferConfig?: CellTransferConfig;
+    columns: readonly TransferColumnConfig[];
+    flattenedRows: readonly R[];
+    selectionRef: React.RefObject<GridSelection | null>;
+    rowContextValue?: ObjectForExtending;
+    headerContextValue?: ObjectForExtending;
+    onRowsChange?: (rows: R[], data: {
+        indexes: number[];
+        column: TransferColumnConfig;
+        rows?: {
+            before: R;
+            after: R;
+        }[];
+        type: RowsChangeType;
+    }) => void;
+    onNotification?: (event: TableNotification) => void;
+}
+export declare function usePaste<R extends ObjectForExtending>({ editModeEnabled, cellTransferConfig, columns, flattenedRows, selectionRef, rowContextValue, headerContextValue, onRowsChange, onNotification }: UsePasteParams<R>): {
+    handlePaste: (clipboardText?: string) => Promise<void>;
+};
+export {};

package/components/TableCanvas/feature-cell-transfer/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../chunks/TableCanvas-BmR3qLnY.cjs");exports.DEFAULT_COPY_HOTKEY=e.DEFAULT_COPY_HOTKEY;exports.DEFAULT_PASTE_HOTKEY=e.DEFAULT_PASTE_HOTKEY;exports.applyValuesToRows=e.applyValuesToRows;exports.buildActiveDataRange=e.buildActiveDataRange;exports.collectMatrixFromTargets=e.collectMatrixFromTargets;exports.collectTextMatrix=e.collectTextMatrix;exports.findFirstDataCol=e.findFirstDataCol;exports.getCellText=e.getCellText;exports.isCellEditable=e.isCellEditable;exports.iterateCellRange=e.iterateCellRange;exports.matchHotkey=e.matchHotkey;exports.normalizePasteValue=e.normalizePasteValue;exports.parseTsv=e.parseTsv;exports.rangeToIndexes=e.rangeToIndexes;exports.resolveSubRowKey=e.resolveSubRowKey;exports.resolveTransferTargets=e.resolveTransferTargets;exports.shouldSkipCell=e.shouldSkipCell;exports.useClipboard=e.useClipboard;exports.useCopy=e.useCopy;exports.useFillHandle=e.useFillHandle;exports.usePaste=e.usePaste;exports.validatePasteValue=e.validatePasteValue;exports.writeCellValue=e.writeCellValue;

package/components/TableCanvas/feature-cell-transfer/index.d.ts

@@ -0,0 +1,21 @@
+export { applyValuesToRows } from './utils/applyValuesToRows';
+export { buildActiveDataRange } from './utils/buildActiveDataRange';
+export { collectMatrixFromTargets } from './utils/collectMatrixFromTargets';
+export { collectTextMatrix } from './utils/collectTextMatrix';
+export { findFirstDataCol } from './utils/findFirstDataCol';
+export { getCellText } from './utils/getCellText';
+export { isCellEditable } from './utils/isCellEditable';
+export { iterateCellRange } from './utils/iterateCellRange';
+export { DEFAULT_COPY_HOTKEY, DEFAULT_PASTE_HOTKEY, matchHotkey } from './utils/matchHotkey';
+export { parseTsv } from './utils/parseTsv';
+export { rangeToIndexes } from './utils/rangeToIndexes';
+export { resolveSubRowKey } from './utils/resolveSubRowKey';
+export { resolveTransferTargets, type TransferTargetKind, type TransferTargets } from './utils/resolveTransferTargets';
+export { shouldSkipCell, type SkipReason } from './utils/shouldSkipCell';
+export { normalizePasteValue, validatePasteValue } from './utils/validatePasteValue';
+export { writeCellValue } from './utils/writeCellValue';
+export type { AllowedFillDirections, CellIterationItem, CellTransferCellInfo, CellTransferConfig, CopyMeta, FillHandleConfig, FillMeta, FillPatternEvent, HotkeyConfig, OverflowBehavior, PasteConfig, PasteMeta, ReadonlyBehavior, Rectangle, RowsChangeType, TransferColumnConfig, ValidationMode } from './types';
+export { useClipboard } from './hooks/useClipboard';
+export { useCopy } from './hooks/useCopy';
+export { useFillHandle } from './hooks/useFillHandle';
+export { usePaste } from './hooks/usePaste';

package/components/TableCanvas/feature-cell-transfer/index.mjs

@@ -0,0 +1,26 @@
+import { X as s, Y as l, Z as t, _ as r, $ as o, a0 as i, a1 as T, a2 as u, a3 as d, a4 as C, a5 as n, a6 as c, a7 as g, a8 as p, a9 as x, aa as E, ab as b, ac as v, ad as F, ae as P, af as _, ag as f, ah as m } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  s as DEFAULT_COPY_HOTKEY,
+  l as DEFAULT_PASTE_HOTKEY,
+  t as applyValuesToRows,
+  r as buildActiveDataRange,
+  o as collectMatrixFromTargets,
+  i as collectTextMatrix,
+  T as findFirstDataCol,
+  u as getCellText,
+  d as isCellEditable,
+  C as iterateCellRange,
+  n as matchHotkey,
+  c as normalizePasteValue,
+  g as parseTsv,
+  p as rangeToIndexes,
+  x as resolveSubRowKey,
+  E as resolveTransferTargets,
+  b as shouldSkipCell,
+  v as useClipboard,
+  F as useCopy,
+  P as useFillHandle,
+  _ as usePaste,
+  f as validatePasteValue,
+  m as writeCellValue
+};