@daisforge/ui 1.10.3

package/components/Table/widgets/control-block/types.d.ts

@@ -0,0 +1,148 @@
+import { DomMetadata } from '../../types/additional.type';
+import { ChangeEvent, FC, ReactNode } from 'react';
+import { IconProps } from '../../../../icons';
+import { DataAttributes, DefaultSidebarTabIds } from '../../types';
+
+type FeatureDetailsBase = {
+    mandatory?: boolean;
+    canBeCompressedInToolsMenu?: boolean;
+    details?: FeatureDetails;
+};
+export type FeatureDetails = ({
+    type: 'button';
+    label: string;
+    onClick: () => void;
+    icon: ReactNode;
+    className?: string;
+} & DataAttributes) | ({
+    type: 'switch';
+    label: string;
+    checked: boolean;
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    className?: string;
+} & DataAttributes) | ({
+    type: 'select';
+    label: string;
+    icon: ReactNode;
+    value: string;
+    options: Array<{
+        value: string;
+        label: string;
+    }>;
+    onChange: (value: string) => void;
+    className?: string;
+} & DataAttributes) | {
+    type: 'custom';
+    render: () => ReactNode;
+};
+export type FeatureItemWithIcon = FeatureDetailsBase & {
+    value: string;
+    label: string;
+    onClick: () => void;
+    Icon: FC<IconProps>;
+    dividerLeft?: boolean;
+    modal?: ReactNode;
+    className?: string;
+} & DataAttributes;
+export type FeatureItemWithCustomIcon = FeatureDetailsBase & {
+    value: string;
+    CustomIconRender: () => ReactNode;
+};
+export type FeatureItem = FeatureItemWithIcon | FeatureItemWithCustomIcon;
+export type SidebarTab = {
+    id: DefaultSidebarTabIds | string;
+    label: string;
+    icon: ReactNode;
+    content: React.ReactNode;
+    showInSidebar?: boolean;
+    title?: string;
+    titleRightSlot?: React.ReactNode;
+    domMetadata?: DomMetadata;
+};
+export type ToolsMenuState = {
+    leftSide: {
+        collapsingBlock: {
+            isActive: boolean;
+        };
+        selectingRowFeature: {
+            isActive: boolean;
+            isLabelVisible: boolean;
+            isCounterVisible: boolean;
+        };
+        editRowFeature: {
+            isActive: boolean;
+            isLabelVisible: boolean;
+            editModeEnabled: boolean;
+        };
+        leftSideInner: Array<{
+            isLabelVisible: boolean;
+            isTargetAction: boolean;
+        }>;
+        isLeftSideInnerInsideDropdown: boolean;
+    };
+    middle: {
+        searchingFeature: {
+            isActive: boolean;
+            searchPosition: 'inline' | 'below';
+        };
+    };
+    rightSide: {
+        rightSideInner: Array<{
+            isLabelVisible: boolean;
+            isTargetAction: boolean;
+        }>;
+        customFeatures: Array<{
+            isMovedToRightSidebar: boolean;
+            isMandatory: boolean;
+            canBeCompressedInToolsMenu: boolean;
+        }>;
+        groupingRowsFeature: {
+            isActive: boolean;
+            isVisibleLabel: boolean;
+            isCounterVisible: boolean;
+        };
+        isRightSideInsideDropdown: boolean;
+    };
+};
+export type InitialWidthsForToolsMenu = {
+    leftSideInner?: Array<number>;
+    rightSideInner?: Array<number>;
+    collapseBlock?: Array<number>;
+};
+export interface CompressionConfig {
+    compressionLevels: CompressionLevel[];
+}
+export interface CompressionLevel {
+    priority: number;
+    target: 'left' | 'center' | 'right';
+    action: CompressionAction;
+    condition?: (state: ToolsMenuState) => boolean;
+}
+export type CompressionAction = {
+    type: 'hide-custom-features';
+    strategy?: 'all' | 'one';
+} | {
+    type: 'remove-label';
+    target: 'editRowFeature' | 'selectingRowFeature' | 'groupingRowFeature' | 'action-buttons';
+    strategy?: 'all' | 'one';
+} | {
+    type: 'remove-counter';
+    target: 'edit' | 'select' | 'action-buttons';
+} | {
+    type: 'move-search-down';
+} | {
+    type: 'hide-right-side-features';
+};
+export interface CompressionCache {
+    cache: Map<string, {
+        originalState: ToolsMenuState;
+        ranges: RangeCache[];
+    }>;
+}
+export interface RangeCache {
+    min: number;
+    max: number;
+    state: ToolsMenuState;
+    stateWidth: number;
+}
+export {};

package/components/Table/widgets/control-block/use-buttons-to-dropdown.d.ts

@@ -0,0 +1,10 @@
+import { FeatureItem } from './types';
+import { ControlBlockButtonProps } from './control-block-button.types';
+import { CSSObject } from 'styled-components';
+import { DropdownItemOption } from '../../../Dropdown';
+
+export declare const useButtonsToDropdownItems: (buttons?: Array<ControlBlockButtonProps | FeatureItem>) => {
+    dropdownItems: DropdownItemOption[];
+    handlerMap: Map<string, (item: DropdownItemOption, event: React.SyntheticEvent) => void>;
+    $summaryCSS: CSSObject;
+};

package/components/Table/widgets/control-block/use-compression-features.d.ts

@@ -0,0 +1,9 @@
+import { InitialWidthsForToolsMenu, ToolsMenuState } from './types';
+
+export declare const useCompressionFeatures: (initialState: ToolsMenuState, measuredWidths?: InitialWidthsForToolsMenu, element?: HTMLDivElement | null) => {
+    compressedState: ToolsMenuState;
+    compress: (availableWidth: number) => void;
+    calculateCurrentWidth: (state: ToolsMenuState) => number;
+    resetCompression: () => void;
+    maxLevel: number;
+};

package/components/Table/widgets/control-block/use-feature-array.d.ts

@@ -0,0 +1,84 @@
+import { FeatureItem, SidebarTab, ToolsMenuState } from './types';
+import { ControlBlockButtonProps } from './control-block-button.types';
+import { ActiveViewModsType } from '../../types';
+import { KeyText, KeyTextMap } from '../../feature-key-text/types';
+import { FullScreenObj } from '../../feature-full-screen/types';
+import { ColumnsControlConfig } from '../../feature-column-control/types';
+import { default as React } from 'react';
+import { ColumnConfig, ObjectForExtending, SIZE, TableConfig } from '../..';
+
+export declare const useFeatureArray: <FilterStateType extends ObjectForExtending, RowType extends ObjectForExtending, RowIdType extends string | number, SummaryRowType = unknown>({ tableConfig, activeView, setActiveView, summaryRowsIsActive, setSummaryRowsIsActive, selectingRowsIsActive, setSelectingRowsIsActive, rowSize, setRowSize, columnsControlEnable, fullScreened, setFullScreened, showRowInstruments, setShowRowInstruments, keyText, setKeyText, rowsGroupingIsActiveInConfig, groupedCols, setGroupedCols, columnConfig, editModeEnabled, setEditModeEnabled, showSearchBlock, setShowSearchBlock, searchQueryLocalValue, placeholderSearchBlock, openControlModal, setOpenControlModal, setColumnsOrder, columnsOrder, pinnedCols, setPinnedCols, hiddenCols, setHiddenCols, getDefaultColumnsOrder, columnsControlConfig, colsWithKeyTextMap, tableConfigKeyTextBoolean, compressionVisibility, enableAdaptiveCompress }: {
+    tableConfig: TableConfig<RowType, SummaryRowType, RowIdType, FilterStateType>;
+    activeView: ActiveViewModsType;
+    setActiveView: React.Dispatch<React.SetStateAction<ActiveViewModsType>>;
+    summaryRowsIsActive: boolean;
+    setSummaryRowsIsActive: React.Dispatch<React.SetStateAction<boolean>>;
+    selectingRowsIsActive: boolean;
+    setSelectingRowsIsActive: React.Dispatch<React.SetStateAction<boolean>>;
+    clearedFiltersValue: FilterStateType | undefined;
+    rowSize: SIZE;
+    setRowSize: React.Dispatch<React.SetStateAction<SIZE>>;
+    columnsControlEnable: boolean;
+    setOpenControlModal: React.Dispatch<React.SetStateAction<boolean>>;
+    fullScreened: boolean;
+    setFullScreened: NonNullable<FullScreenObj['state']>['1'];
+    showRowInstruments: boolean;
+    setShowRowInstruments: React.Dispatch<React.SetStateAction<boolean>>;
+    keyText: KeyText;
+    setKeyText: React.Dispatch<React.SetStateAction<KeyText>>;
+    rowsGroupingIsActiveInConfig: boolean;
+    groupedCols: string[] | undefined;
+    setGroupedCols: React.Dispatch<React.SetStateAction<string[]>> | undefined;
+    columnConfig: readonly ColumnConfig<RowType, SummaryRowType>[];
+    editModeEnabled: boolean;
+    setEditModeEnabled: React.Dispatch<React.SetStateAction<boolean>> | null;
+    showSearchBlock: boolean;
+    setShowSearchBlock: React.Dispatch<React.SetStateAction<boolean>>;
+    placeholderSearchBlock: string;
+    searchQueryLocalValue: string;
+    openControlModal: boolean;
+    setColumnsOrder: React.Dispatch<React.SetStateAction<string[]>>;
+    columnsOrder: string[];
+    pinnedCols: string[];
+    setPinnedCols: React.Dispatch<React.SetStateAction<string[]>>;
+    hiddenCols: string[];
+    setHiddenCols: React.Dispatch<React.SetStateAction<string[]>>;
+    getDefaultColumnsOrder: () => string[];
+    columnsControlConfig: ColumnsControlConfig;
+    colsWithKeyTextMap: KeyTextMap;
+    tableConfigKeyTextBoolean: boolean;
+    compressionVisibility: ToolsMenuState | undefined;
+    enableAdaptiveCompress: boolean;
+}) => {
+    icons: FeatureItem[];
+    featureItems: FeatureItem[];
+    all: FeatureItem[];
+    featureRightButtons: ControlBlockButtonProps[];
+    featureLeftButtons: ControlBlockButtonProps[];
+    isHaveSomeFeature: boolean | undefined;
+    featureSearching: {
+        isActiveSearching: boolean;
+        showSearchBlock: boolean;
+        setShowSearchBlock: React.Dispatch<React.SetStateAction<boolean>>;
+        searchQueryLocalValue: string;
+        placeholderSearchBlock: string;
+    };
+    isHaveSomeFeatureInSidebar: boolean;
+    activeSidebarTabId: string | null;
+    sidebarTabs: SidebarTab[];
+    isActivated: {
+        viewChanging: boolean;
+        rowSize: boolean;
+        columnsControl: boolean;
+        summaryRows: boolean;
+        selectingRows: boolean;
+        fullScreen: boolean;
+        rowInstruments: boolean;
+        keyText: boolean;
+        rowsGrouping: boolean;
+        editingMode: boolean;
+        searching: boolean;
+        filtering: boolean;
+        collapsing: boolean | undefined;
+    };
+};

package/components/Table/widgets/filter-sort-header.d.ts

@@ -0,0 +1,11 @@
+import { ColumnConfig, ObjectForExtending } from '../types';
+import { RenderHeaderCellProps } from 'react-data-grid';
+
+export declare function FilterSortHeader<FilterStateType extends ObjectForExtending, RowType extends ObjectForExtending, SummaryRowType = unknown>({ columnConfig, tableConfigSorting, tableConfigFiltering, tabIndex, columnIsPinned, reorderInHeaderIsActive, subRowIsActiveAndColumnWithArrow, ...rest }: RenderHeaderCellProps<RowType, SummaryRowType> & {
+    columnConfig: ColumnConfig<RowType, SummaryRowType>;
+    tableConfigSorting: boolean;
+    tableConfigFiltering: boolean;
+    columnIsPinned: boolean;
+    reorderInHeaderIsActive: boolean;
+    subRowIsActiveAndColumnWithArrow: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/components/Table/widgets/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../../chunks/Table-CNzEc_EO.cjs");exports.ControlBlock=o.ControlBlock;exports.ControlBlockLazy=o.ControlBlockLazy;exports.FilterSortHeader=o.FilterSortHeader;exports.MassActionsInTable=o.MassActionsInTable;exports.NoRowsFallback=o.NoRowsFallback;exports.TableOrCardsUI=o.TableOrCardsUI;

package/components/Table/widgets/index.d.ts

@@ -0,0 +1,5 @@
+export { ControlBlock, ControlBlockLazy } from './control-block';
+export { FilterSortHeader } from './filter-sort-header';
+export { MassActionsInTable } from './mass-actions';
+export { NoRowsFallback } from './no-rows-fallback';
+export { TableOrCardsUI } from './table-or-card-UI';

package/components/Table/widgets/index.mjs

@@ -0,0 +1,9 @@
+import { bz as s, bA as l, bN as r, bD as b, N as e, bO as t } from "../../../chunks/Table-DTb3FpsK.mjs";
+export {
+  s as ControlBlock,
+  l as ControlBlockLazy,
+  r as FilterSortHeader,
+  b as MassActionsInTable,
+  e as NoRowsFallback,
+  t as TableOrCardsUI
+};

package/components/Table/widgets/mass-actions/MassActions.d.ts

@@ -0,0 +1,11 @@
+import { TableDropdownConfigProps } from '../../components/TableDropdown/types';
+import { MassActionsButtonProps, MassActionsSize } from '../../../MassActions';
+
+export declare const MassActionsInTable: ({ buttons, isHaveSomeFeatureInSidebar, collapsedDropdownProps, bottom, forceShow, size }: {
+    buttons?: MassActionsButtonProps[];
+    collapsedDropdownProps?: TableDropdownConfigProps;
+    isHaveSomeFeatureInSidebar?: boolean;
+    bottom?: number;
+    forceShow?: boolean;
+    size?: MassActionsSize;
+}) => import("react/jsx-runtime").JSX.Element | null;

package/components/Table/widgets/mass-actions/index.cjs

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

package/components/Table/widgets/mass-actions/index.d.ts

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

package/components/Table/widgets/mass-actions/index.mjs

@@ -0,0 +1,4 @@
+import { bD as o } from "../../../../chunks/Table-DTb3FpsK.mjs";
+export {
+  o as MassActionsInTable
+};

package/components/Table/widgets/no-rows-fallback.d.ts

@@ -0,0 +1,3 @@
+export declare const NoRowsFallback: ({ text }: {
+    text?: string;
+}) => import("react/jsx-runtime").JSX.Element;

package/components/Table/widgets/table-or-card-UI.d.ts

@@ -0,0 +1,59 @@
+import { ActiveViewModsType, HighlightActiveType, Key, View } from '../types';
+import { SIZES } from '../styles';
+import { PaginationProps } from '../feature-pagination/types';
+import { TableDropdownConfigProps } from '../components/TableDropdown/types';
+import { CSSObject, CSSProperties } from 'styled-components';
+import { DataGridHandle, DataGridProps } from 'react-data-grid';
+import { default as React, ReactNode, Ref } from 'react';
+import { MassActionsButtonProps, MassActionsSize } from '../../MassActions/types';
+
+export declare const TableOrCardsUI: <RowType, SummRowType, K extends Key = Key>({ containerProps: { viewProp: { activeView, view }, controlBlock, containerId, sidebarBlock, refTableGlobalContainer, refTableContainer, $borderLeftTopRadiusRounded, $borderRightTopRadiusRounded, $borderLeftBottomRadiusRounded, $borderRightBottomRadiusRounded, $containerStyle, $columnsGroupingIsActive, $containerCss, $css, $fullScreened, fullScreenPortal, $tableAndSidebarContainerHeightStyle, $highlightActiveType, collapseButtonPlacement, collapseButtonAboveRightSlot, $borderTopRounded, isHaveSomeFeatureInSidebar }, dataGridProps: { className, rowSize, refTable, onCellContextMenu, ...restDataGridProps }, pagination, setPaginationHeight, loadingOverlayConfig, containerStyle, massActionPanel }: {
+    containerProps: {
+        viewProp: {
+            activeView: ActiveViewModsType;
+            view: View;
+        };
+        controlBlock: ReactNode;
+        sidebarBlock: ReactNode;
+        containerId: string | undefined;
+        refTableGlobalContainer: React.MutableRefObject<HTMLDivElement | null>;
+        refTableContainer: React.Ref<HTMLDivElement>;
+        $borderLeftTopRadiusRounded: boolean | undefined;
+        $borderRightTopRadiusRounded: boolean | undefined;
+        $borderRightBottomRadiusRounded: boolean | undefined;
+        $borderLeftBottomRadiusRounded: boolean | undefined;
+        $columnsGroupingIsActive: boolean;
+        $containerStyle: CSSProperties | undefined;
+        $containerCss: string | CSSObject | undefined;
+        $css: string | CSSObject | undefined;
+        $fullScreened: boolean;
+        fullScreenPortal: Element | DocumentFragment | false;
+        $tableAndSidebarContainerHeightStyle: CSSProperties;
+        $highlightActiveType: HighlightActiveType;
+        collapseButtonPlacement?: 'inside' | 'above';
+        collapseButtonAboveRightSlot?: ReactNode;
+        $borderTopRounded: boolean;
+        isHaveSomeFeatureInSidebar: boolean | undefined;
+    };
+    dataGridProps: {
+        rowSize: keyof typeof SIZES;
+        refTable: Ref<DataGridHandle> | undefined;
+    } & DataGridProps<RowType, SummRowType, K>;
+    pagination: PaginationProps | undefined;
+    setPaginationHeight: React.Dispatch<React.SetStateAction<number>>;
+    loadingOverlayConfig?: {
+        active?: boolean;
+        spinner?: ReactNode;
+        title?: string;
+        subtitle?: string;
+        showSubtitleDelay?: number;
+    };
+    containerStyle?: CSSProperties | undefined;
+    massActionPanel?: {
+        buttons: MassActionsButtonProps[];
+        collapsedDropdownProps?: TableDropdownConfigProps;
+        bottom?: number;
+        show?: boolean;
+        size?: MassActionsSize;
+    };
+}) => import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/TableCanvas.d.ts

@@ -0,0 +1,6 @@
+import { ObjectForExtending, TableProps } from './types';
+
+export interface Props {
+    direction: 'ltr' | 'rtl';
+}
+export declare function TableCanvas<FilterStateType extends ObjectForExtending, RowIdType extends string | number, HeaderContextValueType extends ObjectForExtending, RowContextValueType extends ObjectForExtending, RowType extends ObjectForExtending, SummaryRowType = unknown>({ tableConfig: tableConfigExternal, columnConfig: colsOrGroupColsConfig, rows, bottomSummaryRows, headerContextValue, rowContextValue, refTable, refTableContainer: refTableContainerExternal }: TableProps<FilterStateType, RowIdType, HeaderContextValueType, RowContextValueType, RowType, SummaryRowType>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+import { TableGlideInstanceProps } from './type';
+import { ObjectForExtending } from '../types/utils.type';
+
+export declare const TableGlideInstance: <R extends ObjectForExtending, SR = unknown>({ columns, className, headerHeight, onColumnResize, onVisibleRegionChanged, refTable, onCellContextMenu, onHeaderContextMenu, rows, portalEventTargetRef, containerProps, contentStateOverlay, renderOverlayFeatures, fullScreened, onRowsChange, CellReadOnlyEditor, onCellClicked: onCellClickedExternal, ...rest }: TableGlideInstanceProps<R, SR>) => import("react/jsx-runtime").JSX.Element;

package/components/TableCanvas/TableGlideInstance/adapters/column/adaptColumn.d.ts

@@ -0,0 +1,15 @@
+import { ColumnGlideInstance } from '../../type';
+import { ColumnGlideLast } from '../../../../TableGlide';
+import { ObjectForExtending } from '../../../types';
+
+export interface AdaptColumnInput<R extends ObjectForExtending, SR = unknown> {
+    column: ColumnGlideInstance<R, SR>;
+    group?: string;
+    onFrozen?: () => void;
+}
+export interface AdaptedColumn<R extends ObjectForExtending, SR> {
+    column: ColumnGlideLast<R, SR>;
+    wasFrozen: boolean;
+    groupLength: number;
+}
+export declare const adaptColumn: <R extends ObjectForExtending, SR = unknown>({ column, group: _groupProp, onFrozen }: AdaptColumnInput<R, SR>) => AdaptedColumn<R, SR>;

package/components/TableCanvas/TableGlideInstance/adapters/column/adaptRenderHeaderCell.d.ts

@@ -0,0 +1,5 @@
+import { AdaptRenderHeaderCellInput } from './types';
+import { ObjectForExtending } from '../../../types/utils.type';
+import { ColumnGlideLast } from '../../../../TableGlide';
+
+export declare const adaptRenderHeaderCell: <R extends ObjectForExtending, SR = unknown>({ column }: AdaptRenderHeaderCellInput<R, SR>) => ColumnGlideLast<R, SR>['renderHeaderCell'];

package/components/TableCanvas/TableGlideInstance/adapters/column/adaptTooltipConfig.d.ts

@@ -0,0 +1,6 @@
+import { ColumnGlideInstance } from '../../type';
+import { ObjectForExtending } from '../../../types/utils.type';
+import { ColumnGlideLast } from '../../../../TableGlide';
+
+export declare function adaptCellTooltip<R extends ObjectForExtending, SR>(cellTooltip: ColumnGlideInstance<R, SR>['cellTooltip'], column: ColumnGlideInstance<R, SR>): ColumnGlideLast<R, SR>['cellTooltip'];
+export declare function adaptHeaderCellTooltip<R extends ObjectForExtending, SR>(headerCellTooltip: ColumnGlideInstance<R, SR>['headerCellTooltip'], column: ColumnGlideInstance<R, SR>): ColumnGlideLast<R, SR>['headerCellTooltip'];

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

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

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

@@ -0,0 +1,3 @@
+export { adaptColumn } from './adaptColumn';
+export { adaptRenderHeaderCell } from './adaptRenderHeaderCell';
+export type * from './types';

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

@@ -0,0 +1,5 @@
+import { a as d, b as r } from "../../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  d as adaptColumn,
+  r as adaptRenderHeaderCell
+};

package/components/TableCanvas/TableGlideInstance/adapters/column/types.d.ts

@@ -0,0 +1,9 @@
+import { ColumnGlideInstance, HeaderCellInfoGlideInstance } from '../../type';
+import { CanvasEl } from '../../../../TableGlide';
+import { ObjectForExtending } from '../../../types';
+
+export type AdaptedHeaderCellInfo<R extends ObjectForExtending, SR = unknown> = Pick<HeaderCellInfoGlideInstance<R, SR>, 'column'>;
+export type UserRenderHeaderCell<R extends ObjectForExtending, SR = unknown> = (cellInfo: AdaptedHeaderCellInfo<R, SR>) => CanvasEl;
+export interface AdaptRenderHeaderCellInput<R extends ObjectForExtending, SR = unknown> {
+    column: ColumnGlideInstance<R, SR>;
+}

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

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

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

@@ -0,0 +1 @@
+export * from './column';

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

@@ -0,0 +1,5 @@
+import { a as d, b as r } from "../../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  d as adaptColumn,
+  r as adaptRenderHeaderCell
+};

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

@@ -0,0 +1,16 @@
+import { HandleExpandDetail } from './feature-row-detail/types';
+import { ObjectForExtending } from '../types/utils.type';
+import { SelectingContextType } from '../feature-select-row/selecting-contexts';
+import { ExpandedRowsChangeContextV, ExpandedRowsContextV, HeaderContextValueTypeInstance } from '../contexts';
+
+export type CtxsType<Customs extends ObjectForExtending | void = {}> = {
+    selectingRowCtx: SelectingContextType;
+    headerCtx: HeaderContextValueTypeInstance<ObjectForExtending>;
+    expandedRowsCtx: {
+        expandedRowsIds: ExpandedRowsContextV | null;
+        setExpandedRowsIds: ExpandedRowsChangeContextV | null;
+        handleExpandRowDetail: HandleExpandDetail<ObjectForExtending>;
+        expandButtonColumnKey: string | undefined;
+    };
+    rowCtx: ObjectForExtending;
+} & Customs;

package/components/TableCanvas/TableGlideInstance/feature-row-detail/types.d.ts

@@ -0,0 +1,24 @@
+import { ObjectForExtending, Prettify } from '../../types/utils.type';
+import { ReactNode } from 'react';
+import { IconButtonProps } from '../../../IconButton';
+
+export type HandleExpandDetail<RowType extends ObjectForExtending> = (row: RowType) => void;
+export type IconsPropType = {
+    closed?: ReactNode;
+    opened?: ReactNode;
+    iconButtonProps?: IconButtonProps;
+};
+export type RowDetailConfig<RowType> = {
+    rowKeyGetter: (row: RowType) => string | number;
+    isRowWithDetail: (r: RowType) => boolean;
+    renderRowDetail: (props: {
+        row: RowType;
+        tabIndex: number;
+        onRowChange: (row: RowType) => void;
+        rowIdx: number;
+        colIdx: number;
+    }) => ReactNode;
+    detailHeight: number | ((r: RowType) => number);
+    expandButtonColumnKey: string;
+    icons?: Prettify<IconsPropType>;
+};

package/components/TableCanvas/TableGlideInstance/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("@glideappsfinal/glide-data-grid"),e=require("../../../chunks/TableGlide-DBSIrlp_.cjs"),t=require("../../../chunks/TableCanvas-BmR3qLnY.cjs");Object.defineProperty(exports,"TextCellEntry",{enumerable:!0,get:()=>a.TextCellEntry});exports.Canvas=e.Canvas;exports.TABLE_GLIDE_SIZES=e.TABLE_GLIDE_SIZES;exports.createEmptyCellGlide=e.createEmptyCellGlide;exports.createTextCellGlide=e.createTextCellGlide;exports.isCanvasContent=e.isCanvasContent;exports.isCanvasEl=e.isCanvasEl;exports.isCanvasString=e.isCanvasString;exports.isGlideGridCellObj=e.isGlideGridCellObj;exports.subscribeToCanvasPortalHover=e.subscribeToCanvasPortalHover;exports.subscribeToPortalHoverLock=e.subscribeToPortalHoverLock;exports.tableCanvasFonts=e.fontStyles;exports.tableCanvasTheme=e.THEME;exports.TableGlideInstance=t.TableGlideInstance;

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

@@ -0,0 +1,6 @@
+export type { CanvasNodeTooltipConfig, CanvasNodeTooltipProps, CanvasPortalHoverDetail, CanvasPortalSource } from '../../TableGlide';
+export { Canvas, createEmptyCellGlide, createTextCellGlide, isCanvasContent, isCanvasEl, isCanvasString, isGlideGridCellObj, subscribeToCanvasPortalHover, subscribeToPortalHoverLock, TABLE_GLIDE_SIZES, fontStyles as tableCanvasFonts, THEME as tableCanvasTheme } from '../../TableGlide';
+export { TableGlideInstance } from './TableGlideInstance';
+export type * from './type';
+export type { Rectangle } from '@glideappsfinal/glide-data-grid';
+export { TextCellEntry } from '@glideappsfinal/glide-data-grid';

package/components/TableCanvas/TableGlideInstance/index.mjs

@@ -0,0 +1,19 @@
+import { TextCellEntry as e } from "@glideappsfinal/glide-data-grid";
+import { C as t, a as r, c as o, b as n, i, d as C, e as b, f as v, s as c, g as d, h as T, j as E } from "../../../chunks/TableGlide-B0WCOgRq.mjs";
+import { d as m } from "../../../chunks/TableCanvas-CqJEwXwz.mjs";
+export {
+  t as Canvas,
+  r as TABLE_GLIDE_SIZES,
+  m as TableGlideInstance,
+  e as TextCellEntry,
+  o as createEmptyCellGlide,
+  n as createTextCellGlide,
+  i as isCanvasContent,
+  C as isCanvasEl,
+  b as isCanvasString,
+  v as isGlideGridCellObj,
+  c as subscribeToCanvasPortalHover,
+  d as subscribeToPortalHoverLock,
+  T as tableCanvasFonts,
+  E as tableCanvasTheme
+};

package/components/TableCanvas/TableGlideInstance/reexports-for-external.d.ts

@@ -0,0 +1,25 @@
+import { CanvasBadgeProps as InternalCanvasBadgeProps, CanvasButtonProps as InternalCanvasButtonProps, CanvasContainerProps as InternalCanvasContainerProps, CanvasEmbedIconButtonProps as InternalCanvasEmbedIconButtonProps, CanvasIconButtonProps as InternalCanvasIconButtonProps, CanvasIconProps as InternalCanvasIconProps, CanvasTextProps as InternalCanvasTextProps, Canvas as InternalCanvas } from './index';
+
+export type { CanvasNodeTooltipConfig, CanvasNodeTooltipProps, CanvasPortalHoverDetail, CanvasPortalSource } from '../../TableGlide';
+export { createEmptyCellGlide, createTextCellGlide, isCanvasContent, isCanvasEl, isCanvasString, isGlideGridCellObj, subscribeToCanvasPortalHover, subscribeToPortalHoverLock, TABLE_GLIDE_SIZES, fontStyles as tableCanvasFonts, THEME as tableCanvasTheme } from '../../TableGlide';
+export { TableGlideInstance } from './TableGlideInstance';
+export type * from './type';
+export type { Rectangle } from '@glideappsfinal/glide-data-grid';
+export { TextCellEntry } from '@glideappsfinal/glide-data-grid';
+type CanvasMemberWithoutInteraction<T> = T extends {
+    __canvasType: infer CanvasType;
+} ? T extends (props: infer Props) => infer Result ? ((props: Omit<Props, 'interaction'>) => Result) & {
+    __canvasType: CanvasType;
+} : T : T;
+type PublicCanvas = {
+    [K in keyof typeof InternalCanvas]: CanvasMemberWithoutInteraction<(typeof InternalCanvas)[K]>;
+};
+type PublicCanvasProps<T> = Omit<T, 'interaction'>;
+export declare const Canvas: PublicCanvas;
+export type CanvasBadgeProps = PublicCanvasProps<InternalCanvasBadgeProps>;
+export type CanvasButtonProps = PublicCanvasProps<InternalCanvasButtonProps>;
+export type CanvasContainerProps = PublicCanvasProps<InternalCanvasContainerProps>;
+export type CanvasEmbedIconButtonProps = PublicCanvasProps<InternalCanvasEmbedIconButtonProps>;
+export type CanvasIconButtonProps = PublicCanvasProps<InternalCanvasIconButtonProps>;
+export type CanvasIconProps = PublicCanvasProps<InternalCanvasIconProps>;
+export type CanvasTextProps = PublicCanvasProps<InternalCanvasTextProps>;