@daisforge/ui 1.10.3

package/components/TableCanvas/feature-column-control/types.d.ts

@@ -0,0 +1,37 @@
+import { DomMetadata } from '../types/additional.type';
+import { ReactNode } from 'react';
+
+export type ColumnsControlConfig = {
+    enable: boolean;
+    hiding?: boolean;
+    pinning?: boolean;
+    reorderingAside?: boolean;
+    reorderingHeader?: boolean;
+    onReorderingHeader?: (params: {
+        newOrder: string[];
+        sourceKey: string;
+        targetKey: string;
+    }) => void;
+    columnsLabel?: Record<string, ReactNode | ((isHidden: boolean, isPinned: boolean) => ReactNode)>;
+    orderDefault?: string[];
+    pinnedDefault?: string[];
+    disablePinning?: string[];
+    hiddenDefault?: string[];
+    disableHiding?: string[];
+    onConfirm?: (params: {
+        pinned: string[];
+        order: string[];
+        hidden: string[];
+        changed: {
+            pinned?: 'pinned';
+            order?: 'order';
+            hidden?: 'hidden';
+        };
+    }, setters: {
+        setColumnsOrder: (value: React.SetStateAction<string[]>) => void;
+        setPinnedCols: (value: React.SetStateAction<string[]>) => void;
+        setHiddenCols: (value: React.SetStateAction<string[]>) => void;
+    }) => void;
+    pinDomMetadata?: DomMetadata;
+    switchDomMetadata?: DomMetadata;
+};

package/components/TableCanvas/feature-column-control/useColumnsControl.d.ts

@@ -0,0 +1,24 @@
+import { ColumnsControlConfig } from './types';
+import { KeyTextMap } from '../feature-key-text/types';
+
+export declare const useColumnsControl: ({ tableConfigColumnsControl, tableConfigKeyTextBoolean, colsWithKeyTextMap, columnsGroupingIsActive }: {
+    tableConfigColumnsControl: ColumnsControlConfig | undefined;
+    columnsGroupingIsActive: boolean;
+    tableConfigKeyTextBoolean: boolean;
+    colsWithKeyTextMap: KeyTextMap;
+}) => {
+    columnsControlEnable: boolean;
+    columnsControlConfig: ColumnsControlConfig;
+    columnsControlInControlBlockBoolean: boolean | undefined;
+    reorderInHeaderIsActive: boolean;
+    reorderIsActive: boolean;
+    pinnedCols: string[];
+    setPinnedCols: import('react').Dispatch<import('react').SetStateAction<string[]>>;
+    hiddenCols: string[];
+    setHiddenCols: import('react').Dispatch<import('react').SetStateAction<string[]>>;
+    openControlModal: boolean;
+    setOpenControlModal: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    colsWithKeyTextMap: KeyTextMap;
+    onUnpinColumn: (key: string) => void;
+    getColumnPinningDisabled: (key: string) => boolean;
+};

package/components/TableCanvas/feature-columns-grouping/columnGroupSymbol.d.ts

@@ -0,0 +1,2 @@
+export declare const COLUMN_GROUPS_SYMBOL: unique symbol;
+export declare const COLUMN_GROUPS_MAP_SYMBOL: unique symbol;

package/components/TableCanvas/feature-columns-grouping/fromLastLvlToTree.d.ts

@@ -0,0 +1,6 @@
+import { FlattenedColumnOrColumnGroupConfig } from './types';
+import { ColumnConfigInternal } from '../types/column-config-internal.type';
+import { ColumnConfig, ColumnGroupConfig, ObjectForExtending } from '../types';
+
+export declare const getSeparatedColWithAllParents: <RowType extends ObjectForExtending, SummaryRowType>(col: ColumnConfigInternal<RowType, SummaryRowType>, allColsMap: Map<string, FlattenedColumnOrColumnGroupConfig<RowType, SummaryRowType>>, lastLvlColsMap: Map<string, ColumnConfigInternal<RowType, SummaryRowType>>) => ColumnConfig<RowType, SummaryRowType> | ColumnGroupConfig<RowType, SummaryRowType>;
+export declare const mergeSameCloselyLocatedCols: <RowType extends ObjectForExtending, SummaryRowType, ColGroup extends ColumnGroupConfig<RowType, SummaryRowType>>(array: (ColumnConfig<RowType, SummaryRowType> | ColGroup)[]) => void;

package/components/TableCanvas/feature-columns-grouping/fromTreeToLastLvl.d.ts

@@ -0,0 +1,6 @@
+import { FlattenedColumnOrColumnGroupConfig } from './types';
+import { ColumnConfig, ColumnOrColumnGroupConfig, ObjectForExtending } from '../types';
+
+export declare function isNotGroupColumn<Row extends ObjectForExtending, SummRow>(column: ColumnOrColumnGroupConfig<Row, SummRow>): column is ColumnConfig<Row, SummRow>;
+export declare function getDeepestChildren<Row extends ObjectForExtending, SummRow>(cols: readonly ColumnOrColumnGroupConfig<Row, SummRow>[]): readonly ColumnConfig<Row, SummRow>[];
+export declare const flattenCols: <RowType extends ObjectForExtending, SummaryRowType>(arr: readonly ColumnOrColumnGroupConfig<RowType, SummaryRowType>[], getChildren: (col: ColumnOrColumnGroupConfig<RowType, SummaryRowType>) => ColumnOrColumnGroupConfig<RowType, SummaryRowType>[] | undefined, getParent: (item: ColumnOrColumnGroupConfig<RowType, SummaryRowType>) => ColumnOrColumnGroupConfig<RowType, SummaryRowType> | null, level?: number, parent?: ColumnOrColumnGroupConfig<RowType, SummaryRowType> | null) => Array<FlattenedColumnOrColumnGroupConfig<RowType, SummaryRowType>>;

package/components/TableCanvas/feature-columns-grouping/index.cjs

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

package/components/TableCanvas/feature-columns-grouping/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fromLastLvlToTree';
+export * from './fromTreeToLastLvl';
+export { useGetAllLvlColumnsConfig } from './useGetAllLvlColumnsConfig';
+export { useLastLvlColumnConfig } from './useLastLvlColumnConfig';

package/components/TableCanvas/feature-columns-grouping/index.mjs

@@ -0,0 +1,10 @@
+import { b0 as l, b1 as a, b2 as o, b3 as t, b4 as C, b5 as n, b6 as b } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  l as flattenCols,
+  a as getDeepestChildren,
+  o as getSeparatedColWithAllParents,
+  t as isNotGroupColumn,
+  C as mergeSameCloselyLocatedCols,
+  n as useGetAllLvlColumnsConfig,
+  b as useLastLvlColumnConfig
+};

package/components/TableCanvas/feature-columns-grouping/types.d.ts

@@ -0,0 +1,6 @@
+import { ColumnOrColumnGroupConfig, ObjectForExtending } from '../types';
+
+export type FlattenedColumnOrColumnGroupConfig<RowType extends ObjectForExtending, SummaryRowType> = ColumnOrColumnGroupConfig<RowType, SummaryRowType> & {
+    level: number;
+    parent: ColumnOrColumnGroupConfig<RowType, SummaryRowType> | null;
+};

package/components/TableCanvas/feature-columns-grouping/useGetAllLvlColumnsConfig.d.ts

@@ -0,0 +1,8 @@
+import { FlattenedColumnOrColumnGroupConfig } from './types';
+import { ColumnConfigInternal } from '../types/column-config-internal.type';
+import { ObjectForExtending } from '../types';
+import { ColumnOrColumnGroupGlideInstance } from '../TableGlideInstance';
+
+export declare const useGetAllLvlColumnsConfig: <RowType extends ObjectForExtending, SummaryRowType>(reorderedColumns: readonly ColumnConfigInternal<RowType, SummaryRowType>[], allColsFlattened: FlattenedColumnOrColumnGroupConfig<RowType, SummaryRowType>[], columnsGroupingIsActive: boolean) => {
+    columnsWithParentGroups: readonly ColumnOrColumnGroupGlideInstance<RowType, SummaryRowType>[];
+};

package/components/TableCanvas/feature-columns-grouping/useLastLvlColumnConfig.d.ts

@@ -0,0 +1,121 @@
+import { COLUMN_GROUPS_MAP_SYMBOL, COLUMN_GROUPS_SYMBOL } from './columnGroupSymbol';
+import { ColumnGroupConfig, ColumnOrColumnGroupConfig, ObjectForExtending } from '../types';
+
+export declare const useLastLvlColumnConfig: <RowType extends ObjectForExtending, SummaryRowType>(columnMaybeTreeConfig: readonly ColumnOrColumnGroupConfig<RowType, SummaryRowType>[]) => {
+    columnConfig: {
+        [COLUMN_GROUPS_SYMBOL]: string[];
+        [COLUMN_GROUPS_MAP_SYMBOL]: Map<string, ColumnGroupConfig<RowType, SummaryRowType>>;
+        key: string;
+        width?: number | undefined;
+        name: string | import('..').CanvasEl;
+        colSpan?: number | ((cellInfo: import('..').CellInfoGlideInstance<RowType, SummaryRowType, {}>) => number) | undefined;
+        maxWidth?: number | undefined;
+        minWidth?: number | undefined;
+        renderHeaderCell?: ((cellInfo: import('..').HeaderCellInfoGlideInstance<RowType, SummaryRowType, {}>) => import('..').CanvasContent) | undefined;
+        renderSummaryCell?: ((cellInfo: import('..').SummaryCellInfoGlideInstance<RowType, SummaryRowType, {}>) => import('..').CellContent) | undefined;
+        nameAsString?: string | undefined;
+        contentAlign?: "right" | "left" | "center" | undefined;
+        copyData?: ((string | ((row: RowType) => string)) & (string | ((row: RowType) => string))) | undefined;
+        maxAutoWidth?: number | undefined;
+        headerCellTooltip?: import('..').CanvasNodeTooltipConfig | ((context: {
+            column: import('..').ColumnGlideInstance<RowType, SummaryRowType, {}>;
+            ctxs: {
+                selectingRowCtx: import('../feature-select-row/selecting-contexts').SelectingContextType;
+                headerCtx: import('../contexts').HeaderContextValueTypeInstance<ObjectForExtending>;
+                expandedRowsCtx: {
+                    expandedRowsIds: import('../contexts').ExpandedRowsContextV | null;
+                    setExpandedRowsIds: import('../contexts').ExpandedRowsChangeContextV | null;
+                    handleExpandRowDetail: import('../feature-row-detail/types').HandleExpandDetail<ObjectForExtending>;
+                    expandButtonColumnKey: string | undefined;
+                };
+                rowCtx: ObjectForExtending;
+            };
+            refTable?: import('react').Ref<import('@glideappsfinal/glide-data-grid').DataEditorRef> | undefined;
+            colInd?: number | undefined;
+            theme?: import('../../TableGlide').Theme | undefined;
+        }) => import('..').CanvasNodeTooltipConfig | null) | undefined;
+        cellTooltip?: import('..').CanvasNodeTooltipConfig | ((context: {
+            row: RowType;
+            column: import('..').ColumnGlideInstance<RowType, SummaryRowType, {}>;
+            ctxs: {
+                selectingRowCtx: import('../feature-select-row/selecting-contexts').SelectingContextType;
+                headerCtx: import('../contexts').HeaderContextValueTypeInstance<ObjectForExtending>;
+                expandedRowsCtx: {
+                    expandedRowsIds: import('../contexts').ExpandedRowsContextV | null;
+                    setExpandedRowsIds: import('../contexts').ExpandedRowsChangeContextV | null;
+                    handleExpandRowDetail: import('../feature-row-detail/types').HandleExpandDetail<ObjectForExtending>;
+                    expandButtonColumnKey: string | undefined;
+                };
+                rowCtx: ObjectForExtending;
+            };
+            refTable?: import('react').Ref<import('@glideappsfinal/glide-data-grid').DataEditorRef> | undefined;
+            colInd?: number | undefined;
+            rowInd?: number | undefined;
+            theme?: import('../../TableGlide').Theme | undefined;
+        }) => import('..').CanvasNodeTooltipConfig | null) | undefined;
+        renderCell?: ((cellInfo: import('../types').CellInfo<RowType, SummaryRowType, {}>) => import('..').CellContent) | undefined;
+        renderCellPreview?: import('../types').RenderCellPreview<RowType, SummaryRowType, {}> | undefined;
+        sortingType?: "stringSort" | "numberSort" | import('../types').Comparator<RowType> | undefined;
+        searching?: {
+            valueInRow: (row: RowType) => string | number;
+        } | undefined;
+        filtering?: ({
+            keyInFilterState: string;
+            valueInRow?: ((row: RowType) => string | number) | undefined;
+        } & ({
+            component: "input";
+            filter: "includes" | "startWith" | "equal" | ((filterV: string, rowValue: string) => boolean);
+        } | {
+            component: "select";
+            beforeList?: ((props: import('../feature-filtering/header-filter-button/types').FilterComponentInPopoverProps<ObjectForExtending, import('../types').ColumnConfig<RowType, SummaryRowType, {}>>) => import('react').ReactNode) | undefined;
+            filter: {
+                typeOfValue: "single";
+                filteringType?: ((filterV: string, rowValue: string) => boolean) | undefined;
+            } | {
+                typeOfValue: "multiple";
+                filteringType?: ((filterV: string[], rowValue: string) => boolean) | undefined;
+            };
+            selectOptions: {
+                type: "constant";
+                options: import('../types').SelectOptions[];
+            } | {
+                type: "stateInHeaderContext";
+                optionsKeyInHeaderContext: string;
+            };
+            listMaxHeight?: string | undefined;
+        } | {
+            component: "custom";
+            customRender: (props: import('../feature-filtering/header-filter-button/types').FilterComponentInPopoverProps<ObjectForExtending, import('../types').ColumnConfig<RowType, SummaryRowType, {}>>) => import('react').ReactNode;
+            filter?: ((filterValue: unknown, rowValue: unknown) => boolean) | undefined;
+            compareWithClearedValue?: ((clearedValue: unknown, currV: unknown) => boolean) | undefined;
+        })) | undefined;
+        contentFormat?: import('..').ContentFormat | undefined;
+        editingCell?: import('../types').Editing<RowType, SummaryRowType> | undefined;
+        subRow?: ({
+            isColumnWithArrow?: boolean | ((props: {
+                keyText: import('../feature-key-text/types').KeyText;
+            }) => boolean) | undefined;
+            hideHeaderExpandAllArrow?: boolean | undefined;
+            parentKeyAsDefault?: boolean | undefined;
+            contentFormat?: import('..').ContentFormat | undefined;
+            renderSubRowCell?: import('../types').RenderSubRowCell<ObjectForExtending, unknown, {}> | undefined;
+        } & ({
+            keyOfColumnInSubRow: string | number | ((lvl: number) => string | number);
+            editingCell: import('../types').Editing<any, any>;
+        } | {
+            editingCell?: undefined;
+            keyOfColumnInSubRow?: string | number | ((lvl: number) => string | number) | undefined;
+        })) | undefined;
+        rowsGrouping?: import('../feature-rows-grouping/types').ColumnRowsGrouping<RowType, import('../types').ColumnConfig<RowType, SummaryRowType, {}>> | undefined;
+        keyText?: import('../types').KeyTextColumnConfig<RowType, SummaryRowType> | undefined;
+        themeOverride?: ((cellInfo: import('../types').CellInfo<RowType, SummaryRowType, {}>, lvl: number) => Partial<{
+            bgCell: string;
+            cellHorizontalPadding: number;
+            cellVerticalPadding: number;
+        }> | undefined) | undefined;
+    }[];
+    allColsFlattened: import('./types').FlattenedColumnOrColumnGroupConfig<RowType, SummaryRowType>[];
+    allGroupsMap: Map<string, ColumnGroupConfig<RowType, SummaryRowType>>;
+    columnsGroupingIsActive: boolean;
+    maxLevelOfGroups: number;
+};

package/components/TableCanvas/feature-content-state/TableContentStateOverlay.d.ts

@@ -0,0 +1,8 @@
+import { TableContentStateOverlay as TableContentStateOverlayType } from './types';
+
+type TableContentStateOverlayProps = {
+    overlay: TableContentStateOverlayType;
+    topOffset: number;
+};
+export declare const TableContentStateOverlay: ({ overlay, topOffset }: TableContentStateOverlayProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/components/TableCanvas/feature-content-state/index.cjs

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

package/components/TableCanvas/feature-content-state/index.d.ts

@@ -0,0 +1,3 @@
+export { TableContentStateOverlay } from './TableContentStateOverlay';
+export type { TableContentStateEmptyOverlay, TableContentStateErrorOverlay } from './types';
+export { useContentStateOverlay } from './useContentStateOverlay';

package/components/TableCanvas/feature-content-state/index.mjs

@@ -0,0 +1,5 @@
+import { c as a, u as n } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  a as TableContentStateOverlay,
+  n as useContentStateOverlay
+};

package/components/TableCanvas/feature-content-state/styled.d.ts

@@ -0,0 +1,9 @@
+export declare const OverlayContainer: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {
+    $topOffset: number;
+    $displayMode: 'body-overlay' | 'full-content';
+    $borderLeftTopRadiusRounded: boolean;
+    $borderRightTopRadiusRounded: boolean;
+    $borderLeftBottomRadiusRounded: boolean;
+    $borderRightBottomRadiusRounded: boolean;
+}, never>;
+export declare const OverlayContent: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;

package/components/TableCanvas/feature-content-state/types.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { ErrorPageProps } from '../../../layouts/ErrorPage';
+import { EmptyStateProps } from '../../EmptyState';
+
+type TableContentStateFrame = {
+    displayMode?: 'body-overlay' | 'full-content';
+    borderLeftTopRadiusRounded?: boolean;
+    borderRightTopRadiusRounded?: boolean;
+    borderLeftBottomRadiusRounded?: boolean;
+    borderRightBottomRadiusRounded?: boolean;
+    custom?: ReactNode;
+};
+export type TableContentStateEmptyOverlay = {
+    kind: 'empty';
+} & TableContentStateFrame & Partial<EmptyStateProps>;
+export type TableContentStateErrorOverlay = {
+    kind: 'error';
+    errorPageProps?: Partial<ErrorPageProps>;
+} & TableContentStateFrame;
+export type TableContentStateOverlay = TableContentStateEmptyOverlay | TableContentStateErrorOverlay;
+export type TableCanvasEmptyStateConfig = TableCanvasContentStateBase & Partial<EmptyStateProps>;
+type TableCanvasContentStateBase = {
+    enabled: boolean;
+    custom?: ReactNode;
+};
+export type TableCanvasErrorStateConfig = TableCanvasContentStateBase & Partial<ErrorPageProps>;
+export {};

package/components/TableCanvas/feature-content-state/useContentStateOverlay.d.ts

@@ -0,0 +1,17 @@
+import { TableCanvasEmptyStateConfig, TableCanvasErrorStateConfig, TableContentStateOverlay } from './types';
+
+export declare const useContentStateOverlay: ({ borderLeftBottomRadiusRounded, borderLeftTopRadiusRounded, borderRightBottomRadiusRounded, borderRightTopRadiusRounded, errorStateConfig, emptyStateConfig, hasRenderableHeaders, isLoadingTable, rowsLength }: {
+    borderLeftBottomRadiusRounded: boolean;
+    borderLeftTopRadiusRounded: boolean;
+    borderRightBottomRadiusRounded: boolean;
+    borderRightTopRadiusRounded: boolean;
+    errorStateConfig: TableCanvasErrorStateConfig | undefined;
+    emptyStateConfig: TableCanvasEmptyStateConfig | undefined;
+    hasRenderableHeaders: boolean;
+    isLoadingTable: boolean;
+    rowsLength: number;
+}) => {
+    showErrorState: boolean;
+    showEmptyState: boolean;
+    contentStateOverlay: TableContentStateOverlay | undefined;
+};

package/components/TableCanvas/feature-context-menu/constants.d.ts

@@ -0,0 +1 @@
+export declare const HEADER_CTX_MENU_OFFSET: [number, number];

package/components/TableCanvas/feature-context-menu/hooks/useCloseContextMenuOnRegionChange.d.ts

@@ -0,0 +1,14 @@
+import { ObjectForExtending } from '../../types';
+
+interface UseCloseContextMenuOnRegionChangeOptions {
+    scrollThreshold?: number;
+}
+export declare function useCloseContextMenuOnRegionChange<RowType extends ObjectForExtending, SummaryRowType>(contextMenu: {
+    isOpen: boolean;
+    close: () => void;
+}, options?: UseCloseContextMenuOnRegionChangeOptions): (range: import('@glideappsfinal/glide-data-grid').Rectangle, tx: number, ty: number, extras: {
+    selected?: import('@glideappsfinal/glide-data-grid').Item | undefined;
+    freezeRegion?: import('@glideappsfinal/glide-data-grid').Rectangle | undefined;
+    freezeRegions?: readonly import('@glideappsfinal/glide-data-grid').Rectangle[] | undefined;
+}) => void;
+export {};

package/components/TableCanvas/feature-context-menu/index.cjs

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

package/components/TableCanvas/feature-context-menu/index.d.ts

@@ -0,0 +1,3 @@
+export { useCloseContextMenuOnRegionChange } from './hooks/useCloseContextMenuOnRegionChange';
+export type { CellContextMenuDropdownProps, ContextMenuDropdownItem, DropdownContextMenu, HeaderContextMenuDropdownProps } from './types';
+export * from './ui/ContextMenu';

package/components/TableCanvas/feature-context-menu/index.mjs

@@ -0,0 +1,5 @@
+import { bd as o, be as t } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  o as ContextMenu,
+  t as useCloseContextMenuOnRegionChange
+};

package/components/TableCanvas/feature-context-menu/types.d.ts

@@ -0,0 +1 @@
+export { CellContextMenuDropdownProps, ContextMenuDropdownItem, ContextMenuDropdownProps, DropdownContextMenu, HeaderContextMenuDropdownProps } from '../TableGlideInstance/type';

package/components/TableCanvas/feature-context-menu/ui/ContextMenu.d.ts

@@ -0,0 +1,4 @@
+export interface ContextMenuProps {
+    containerEl?: HTMLElement | null;
+}
+export declare const ContextMenu: ({ containerEl }: ContextMenuProps) => import("react/jsx-runtime").JSX.Element | null;

package/components/TableCanvas/feature-context-menu/ui/ContextMenu.styled.d.ts

@@ -0,0 +1,12 @@
+interface MenuContainerProps {
+    $isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    $isFixed?: boolean;
+    $zIndex?: number;
+}
+export declare const HiddenTriggerButton: import('styled-components').StyledComponent<"button", import('styled-components').DefaultTheme, {}, never>;
+export declare const MenuContainer: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, MenuContainerProps, never>;
+export {};

package/components/TableCanvas/feature-edit/CellEditorCombobox.d.ts

@@ -0,0 +1,9 @@
+import { CellEditorComboboxProps } from './types';
+import { EditingCellInfo, ObjectForExtending } from '../types';
+import { ReactElement } from 'react';
+import { ComboboxItemOption } from '../../Combobox';
+
+export declare const CellEditorCombobox: <T extends ComboboxItemOption>(p: CellEditorComboboxProps<T>) => ReactElement;
+export declare function CellEditorComboboxInternal<TRow extends ObjectForExtending, TSummaryRow>({ row, column, cellWidth, cellHeight, onRowChange, disableLeftOffset, readOnly, theme }: EditingCellInfo<TRow, TSummaryRow> & {
+    disableLeftOffset: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/feature-edit/CellEditorNumberFormat.d.ts

@@ -0,0 +1,10 @@
+import { CellEditorNumberFormatProps } from './types';
+import { EditingCellInfo, ObjectForExtending } from '../types';
+import { ContentFormat } from '../TableGlideInstance/type';
+import { default as React } from 'react';
+
+export declare const CellEditorNumberFormat: React.ForwardRefExoticComponent<Omit<CellEditorNumberFormatProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export declare function CellEditorNumberFormatInternal<TRow extends ObjectForExtending, TSummaryRow>({ row, column, onRowChange, readOnly, cellWidth, cellHeight, initialValue, formatOptions, disableLeftOffset }: EditingCellInfo<TRow, TSummaryRow> & {
+    formatOptions: ContentFormat | undefined;
+    disableLeftOffset: boolean | undefined;
+}): import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/feature-edit/CellEditorTextArea.d.ts

@@ -0,0 +1,9 @@
+import { CellEditorTextAreaProps } from './types';
+import { EditingCellInfo, ObjectForExtending } from '../types';
+import { default as React } from 'react';
+
+export declare const CellEditorTextArea: React.ForwardRefExoticComponent<Omit<CellEditorTextAreaProps, "ref"> & React.RefAttributes<HTMLTextAreaElement>>;
+export declare function CellEditorTextAreaInternal<TRow extends ObjectForExtending, TSummaryRow>({ row, column, initialValue, onRowChange, readOnly, cellHeight, cellWidth, disableLeftOffset, theme, contentAlign }: EditingCellInfo<TRow, TSummaryRow> & {
+    disableLeftOffset: boolean | undefined;
+    contentAlign?: 'left' | 'right' | 'center';
+}): import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/feature-edit/CellReadOnlyEditor.d.ts

@@ -0,0 +1,3 @@
+import { CellReadOnlyEditorProps, ObjectForExtending } from '../types';
+
+export declare const CellReadOnlyEditor: <R extends ObjectForExtending, SR>(props: CellReadOnlyEditorProps<R, SR>) => import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/feature-edit/getEditingEnabledState.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const getEditingEnabledState: (external: undefined | boolean | [boolean, React.Dispatch<React.SetStateAction<boolean>>], innerState: [boolean, React.Dispatch<React.SetStateAction<boolean>>]) => [boolean, import('react').Dispatch<import('react').SetStateAction<boolean>>] | readonly [boolean, null];

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../chunks/TableCanvas-BmR3qLnY.cjs");exports.CellEditorCombobox=e.CellEditorCombobox;exports.CellEditorComboboxInternal=e.CellEditorComboboxInternal;exports.CellEditorNumberFormat=e.CellEditorNumberFormat;exports.CellEditorNumberFormatInternal=e.CellEditorNumberFormatInternal;exports.CellEditorTextArea=e.CellEditorTextArea;exports.CellEditorTextAreaInternal=e.CellEditorTextAreaInternal;exports.CellReadOnlyEditor=e.CellReadOnlyEditor;exports.autoFocus=e.autoFocus;exports.autoFocusAndSelect=e.autoFocusAndSelect;exports.getEditingEnabledState=e.getEditingEnabledState;exports.isServiceEditableColumn=e.isServiceEditableColumn;

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

@@ -0,0 +1,7 @@
+export * from './CellEditorCombobox';
+export * from './CellEditorNumberFormat';
+export * from './CellEditorTextArea';
+export { CellReadOnlyEditor } from './CellReadOnlyEditor';
+export { getEditingEnabledState } from './getEditingEnabledState';
+export { isServiceEditableColumn } from './typeGuards';
+export * from './utils';

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

@@ -0,0 +1,14 @@
+import { bf as l, bg as o, bh as t, bi as b, bj as r, bk as s, bl as i, bm as d, bn as n, bo as C, bp as E } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  l as CellEditorCombobox,
+  o as CellEditorComboboxInternal,
+  t as CellEditorNumberFormat,
+  b as CellEditorNumberFormatInternal,
+  r as CellEditorTextArea,
+  s as CellEditorTextAreaInternal,
+  i as CellReadOnlyEditor,
+  d as autoFocus,
+  n as autoFocusAndSelect,
+  C as getEditingEnabledState,
+  E as isServiceEditableColumn
+};

package/components/TableCanvas/feature-edit/typeGuards.d.ts

@@ -0,0 +1,5 @@
+import { ColumnConfigInternal } from '../types/column-config-internal.type';
+import { ColumnConfig, ObjectForExtending } from '../types';
+
+export declare const isServiceEditableColumn: <RowType extends ObjectForExtending, SummaryRowType>(col: ColumnConfig<RowType, SummaryRowType>) => col is ColumnConfigInternal<RowType, SummaryRowType>;
+export declare const isEditableCell: <RowType extends ObjectForExtending, SummaryRowType>(editingCellConfig: ColumnConfig<RowType, SummaryRowType>['editingCell'], row: RowType, tableConfigRowEditable: ((r: RowType) => boolean) | undefined) => boolean;

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

@@ -0,0 +1,26 @@
+import { TextCellEntry } from '../TableGlideInstance';
+import { ComponentProps } from 'react';
+import { NumberFormatCompProps } from '../../NumberFormat';
+import { ComboboxCompProps, ComboboxItemOption } from '../../Combobox';
+
+export type CustomCellStyleProps = {
+    cellWidth: number;
+    cellHeight: number;
+    disableLeftOffset?: boolean | undefined;
+};
+export type EmptyObj = Record<string, never>;
+export type CustomCellStyleNumberFormatProps = {
+    align?: 'left' | 'center' | 'right';
+    autoFocusType: 'autoFocus' | 'autoFocusAndSelect' | 'none';
+} & CustomCellStyleProps;
+export type CellEditorNumberFormatProps = Omit<NumberFormatCompProps, 'view' | 'size'> & CustomCellStyleNumberFormatProps;
+export type { ComboboxItemOption };
+export type CellEditorComboboxProps<T extends ComboboxItemOption> = ComboboxCompProps<T> & CustomCellStyleProps & {
+    autoFocusType: 'autoFocus' | 'none';
+    paddingInline: number;
+};
+export type CellEditorTextAreaProps = Omit<ComponentProps<typeof TextCellEntry>, 'highlight'> & {
+    autoFocusType?: 'autoFocus' | 'autoFocusAndSelect' | 'none';
+    paddingInline: number;
+    containerClassName?: string;
+} & CustomCellStyleProps;

package/components/TableCanvas/feature-edit/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function autoFocusAndSelect<T extends HTMLInputElement | HTMLTextAreaElement | null>(input: T | null): void;
+export declare function autoFocus<T extends HTMLInputElement | HTMLTextAreaElement | null>(input: T | null): void;

package/components/TableCanvas/feature-filtering/combobox/combobox.d.ts

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { SIZE } from '../..';
+
+type Single = {
+    mode?: 'single';
+    value: string;
+    onChange: (v: string) => void;
+};
+type Multiple = {
+    mode?: 'multiple';
+    value: string[];
+    onChange: (v: string[]) => void;
+};
+export declare const ComboboxX: ({ value, onChange, mode, options, tabIndex, beforeList, size, listMaxHeight, width }: (Single | Multiple) & {
+    options: {
+        text: string;
+        value: string;
+    }[];
+    tabIndex?: number | undefined;
+    size?: SIZE;
+    beforeList?: ReactNode;
+    listMaxHeight?: string;
+    width?: string;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};

package/components/TableCanvas/feature-filtering/combobox/index.cjs

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

package/components/TableCanvas/feature-filtering/combobox/index.d.ts

@@ -0,0 +1,2 @@
+export { ComboboxX } from './combobox';
+export { StyledListItem as TableFilterSelectListItem } from './styled';

package/components/TableCanvas/feature-filtering/combobox/index.mjs

@@ -0,0 +1,5 @@
+import { da as t, br as a } from "../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  t as ComboboxX,
+  a as TableFilterSelectListItem
+};