@daisforge/ui 1.10.3

package/components/TableGlide/lib/canvas/primitives/index.mjs

@@ -0,0 +1,13 @@
+import { aB as n, aC as C, aD as v, aE as o, aF as t, aG as e, aH as B, aI as c, aJ as I, aK as r } from "../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  n as CanvasBadge,
+  C as CanvasButton,
+  v as CanvasChevron,
+  o as CanvasEmbedIconButton,
+  t as CanvasIcon,
+  e as CanvasIconButton,
+  B as CanvasLink,
+  c as CanvasRect,
+  I as CanvasSkeleton,
+  r as CanvasText
+};

package/components/TableGlide/lib/canvas/utils/colors.d.ts

@@ -0,0 +1 @@
+export declare function applyAlpha(hex: string, opacity: number): string;

package/components/TableGlide/lib/canvas/utils/dimensionUtils.d.ts

@@ -0,0 +1 @@
+export declare const normalizeDimensionValue: (value?: number | string) => number | '100%' | undefined;

package/components/TableGlide/lib/canvas/utils/iconUtils.d.ts

@@ -0,0 +1,7 @@
+import { ReactElement } from 'react';
+
+export declare function reactIconToSvg(iconElement: ReactElement): string;
+export declare function isReactIcon(value: unknown): value is ReactElement;
+export declare function normalizeIcon(icon: string | ReactElement): string;
+export declare function clearIconCache(): void;
+export declare function getIconCacheSize(): number;

package/components/TableGlide/lib/canvas/utils/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("../../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.CANVAS_PORTAL_EVENT=o.CANVAS_PORTAL_EVENT;exports.clearIconCache=o.clearIconCache;exports.dispatchCanvasPortalHover=o.dispatchCanvasPortalHover;exports.getIconCacheSize=o.getIconCacheSize;exports.isPortalHoverLocked=o.isPortalHoverLocked;exports.isReactIcon=o.isReactIcon;exports.lockPortalHover=o.lockPortalHover;exports.normalizeDimensionValue=o.normalizeDimensionValue;exports.normalizeIcon=o.normalizeIcon;exports.reactIconToSvg=o.reactIconToSvg;exports.subscribeToCanvasPortalHover=o.subscribeToCanvasPortalHover;exports.subscribeToPortalHoverLock=o.subscribeToPortalHoverLock;

package/components/TableGlide/lib/canvas/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { clearIconCache, getIconCacheSize, isReactIcon, normalizeIcon, reactIconToSvg, } from './iconUtils';
+export type { CanvasNodeTooltipConfig, CanvasNodeTooltipProps, CanvasPortalHoverDetail, CanvasPortalHoverListener, CanvasPortalSource, TooltipContextShape, } from './portalHoverEvents';
+export { CANVAS_PORTAL_EVENT, dispatchCanvasPortalHover, isPortalHoverLocked, lockPortalHover, subscribeToCanvasPortalHover, subscribeToPortalHoverLock, } from './portalHoverEvents';
+export { normalizeDimensionValue } from './dimensionUtils';

package/components/TableGlide/lib/canvas/utils/index.mjs

@@ -0,0 +1,15 @@
+import { be as s, bf as e, bg as r, bh as c, bi as b, bj as n, bk as i, bl as l, bm as t, bn as v, s as P, g as m } from "../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  s as CANVAS_PORTAL_EVENT,
+  e as clearIconCache,
+  r as dispatchCanvasPortalHover,
+  c as getIconCacheSize,
+  b as isPortalHoverLocked,
+  n as isReactIcon,
+  i as lockPortalHover,
+  l as normalizeDimensionValue,
+  t as normalizeIcon,
+  v as reactIconToSvg,
+  P as subscribeToCanvasPortalHover,
+  m as subscribeToPortalHoverLock
+};

package/components/TableGlide/lib/canvas/utils/portalHoverEvents.d.ts

@@ -0,0 +1,51 @@
+import { TooltipProps } from '../../../../Tooltip';
+import { CanvasNode } from '../core/CanvasNode';
+
+type InteractionLockListener = (locked: boolean) => void;
+export declare function lockPortalHover(): () => void;
+export declare function isPortalHoverLocked(): boolean;
+export declare function subscribeToPortalHoverLock(listener: InteractionLockListener): () => void;
+export type CanvasPortalSource = 'header' | 'cell';
+export interface TooltipContextShape<T = unknown> {
+    column?: T;
+    row?: T;
+    ctxs?: T;
+    refTable?: T;
+    colInd?: T;
+    rowInd?: T;
+    theme?: T;
+}
+export interface TooltipContext<T = unknown> {
+    column?: T;
+    row?: T;
+    ctxs?: T;
+    refTable?: T;
+    colInd?: T;
+    rowInd?: T;
+    theme?: T;
+}
+export type CanvasNodeTooltipProps = Pick<TooltipProps, 'placement' | 'view' | 'minWidth' | 'maxWidth'>;
+export type CanvasNodeTooltipConfig = string | (CanvasNodeTooltipProps & {
+    text: string;
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+});
+export interface CanvasPortalHoverDetail<TContext extends TooltipContextShape = TooltipContextShape> {
+    visible: boolean;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    node?: CanvasNode | null;
+    nodeId?: string;
+    source?: CanvasPortalSource;
+    originId?: string;
+    tooltipContext?: TContext;
+    tooltipFromNode?: CanvasNodeTooltipConfig;
+    priority?: number;
+}
+export type CanvasPortalHoverListener = (detail: CanvasPortalHoverDetail) => void;
+export declare const CANVAS_PORTAL_EVENT = "basic-grid-canvas-portal-hover";
+export declare function dispatchCanvasPortalHover(detail: CanvasPortalHoverDetail, target?: EventTarget | null, immediate?: boolean): void;
+export declare function subscribeToCanvasPortalHover(listener: CanvasPortalHoverListener, target?: EventTarget | null): () => void;
+export {};

package/components/TableGlide/lib/canvas/utils/textOverflow.d.ts

@@ -0,0 +1,32 @@
+export type CanvasTextOverflow = 'clip' | 'ellipsis';
+export interface ResolvedOverflowText {
+    text: string;
+    didTruncate: boolean;
+    width: number;
+}
+interface ResolveOverflowTextArgs {
+    ctx: CanvasRenderingContext2D;
+    text: string;
+    font: string;
+    maxWidth: number;
+    textOverflow: CanvasTextOverflow;
+    ellipsis: string;
+    forceEllipsis?: boolean;
+}
+interface ResolveWrappedOverflowTextArgs {
+    ctx: CanvasRenderingContext2D;
+    lines: readonly string[];
+    font: string;
+    maxWidth: number;
+    maxLines: number;
+    textOverflow: CanvasTextOverflow;
+    ellipsis: string;
+}
+export interface ResolvedWrappedOverflowText {
+    lines: string[];
+    didClamp: boolean;
+}
+export declare function resolveOverflowText(args: ResolveOverflowTextArgs): ResolvedOverflowText;
+export declare function resolveWrappedOverflowText({ ctx, lines, font, maxWidth, maxLines, textOverflow, ellipsis, }: ResolveWrappedOverflowTextArgs): ResolvedWrappedOverflowText;
+export declare function invalidateOverflowTextCache(): void;
+export {};

package/components/TableGlide/styled.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const StyledOverlayPortal: import('styled-components').StyledComponent<"div", import('styled-components').DefaultTheme, {}, never>;
+export declare const StyledGlideDataEditor: import('react').ForwardRefExoticComponent<import('@glideappsfinal/glide-data-grid').DataEditorProps & import('react').RefAttributes<import('@glideappsfinal/glide-data-grid').DataEditorRef>>;

package/components/TableGlide/theming/activeTheme.type.d.ts

@@ -0,0 +1 @@
+export type ActiveTheme = 'light' | 'dark' | 'highContrastLight';

package/components/TableGlide/theming/custom-colors.d.ts

@@ -0,0 +1,23 @@
+import { GlideSizeConfig, SIZE } from '../constants';
+import { ActiveTheme } from './activeTheme.type';
+
+export type ThemeCustoms = ReturnType<typeof getCustomColors> & {
+    rowSize: SIZE;
+    activeSizes: GlideSizeConfig;
+};
+export declare const getCustomColors: (activeTheme: ActiveTheme) => {
+    tokens: import('../tokens').Tokens;
+    fonts: import('../fonts').Fonts;
+    fontMetrics: import('../fonts').FontMetrics;
+    bgEditableCell: "#FFF6E5" | "#211807" | "#F1DDB8";
+    bgEditableCellHovered: "#FFF4E0" | "#2A1F09" | "#E8D4AD";
+    selectionCheckboxBg: "#ECF6FC" | "#CFE5F2";
+    selectionActiveBg: "#E2F1FB" | "#BFDDF4";
+    selectionActiveCheckboxBg: "#D1E9F8" | "#9BCAEA";
+    selectionServiceBg: "#ECF6FC" | "#CFE5F2";
+    selectionServiceActiveBg: "#D4E7F2" | "#B9D6E7";
+    errorOutlineColor: "#FF3D51" | "#E9203F";
+    bgRowHovered: "#E8EEF2" | "#F7F9FB";
+    bgServiceRowHovered: "#D4E7F2" | "#B9D6E7";
+    bgSelectedRowHovered: "#DEECF5" | "#C2DCEB";
+};

package/components/TableGlide/theming/glide-colors.d.ts

@@ -0,0 +1,17 @@
+import { ActiveTheme } from './activeTheme.type';
+
+export declare const getGlideColors: (activeTheme: ActiveTheme) => {
+    accentColor: "#0058A2" | "#0b7ecb";
+    accentLight: "#DAE8F1" | "#E2F1FB";
+    textDark: "#13181BF5";
+    textHeader: "#13181BF5";
+    textHeaderSelected: "#13181BF5";
+    textGroupHeader: "#13181BF5";
+    bgCell: "#FFFFFF";
+    bgHeader: "#ECF6FCFF" | "#CFE5F2FF";
+    bgHeaderHasFocus: "#ECF6FCFF" | "#B9D6E7";
+    bgHeaderHovered: "#DEECF5" | "#C2DCEB";
+    borderColor: "#D5DFE6" | "#C4CFD7";
+    bgGroupHeader: "#ECF6FCFF" | "#CFE5F2FF";
+    bgGroupHeaderHovered: "#DEECF5" | "#C2DCEB";
+};

package/components/TableGlide/theming/index.cjs

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

package/components/TableGlide/theming/index.d.ts

@@ -0,0 +1,6 @@
+import { Theme } from '../types';
+import { SIZE } from '../constants';
+import { ActiveTheme } from './activeTheme.type';
+
+export declare const getTheme: (rowSize?: SIZE | undefined, activeTheme?: ActiveTheme) => Theme;
+export declare const THEME: Theme;

package/components/TableGlide/theming/index.mjs

@@ -0,0 +1,5 @@
+import { j as a, bE as m } from "../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  a as THEME,
+  m as getTheme
+};

package/components/TableGlide/theming/size-tokens.d.ts

@@ -0,0 +1,26 @@
+export declare const ROW_SIZE_TOKENS: {
+    readonly small: {
+        readonly rowHeight: 20;
+        readonly cellVerticalPadding: 4;
+        readonly cellHorizontalPadding: 4;
+        readonly textfieldSize: "xs";
+    };
+    readonly medium: {
+        readonly rowHeight: 32;
+        readonly cellVerticalPadding: 7;
+        readonly cellHorizontalPadding: 8;
+        readonly textfieldSize: "s";
+    };
+    readonly big: {
+        readonly rowHeight: 48;
+        readonly cellVerticalPadding: 12;
+        readonly cellHorizontalPadding: 16;
+        readonly textfieldSize: "s";
+    };
+};
+export type RowSizeTokens = typeof ROW_SIZE_TOKENS;
+type RowSizeName = keyof RowSizeTokens;
+export type RowSizeToken = RowSizeTokens[RowSizeName];
+export declare const getRowHeightBySize: (size: RowSizeName) => 20 | 32 | 48;
+export declare const getTextfieldSizeByRowSize: (size: RowSizeName) => "s" | "xs";
+export {};

package/components/TableGlide/theming/sizes.d.ts

@@ -0,0 +1,24 @@
+import { SIZE } from '../constants';
+
+export declare const getSizeProps: (rowSize?: SIZE) => {
+    headerFontStyle: string;
+    baseFontStyle: string;
+    fontFamily: string;
+    editorFontSize: string;
+    lineHeight: number;
+    cellHorizontalPadding: 16 | 8 | 4;
+    cellVerticalPadding: 4 | 7 | 12;
+    activeSizes: {
+        readonly cellVerticalPadding: 12;
+        readonly cellHorizontalPadding: 16;
+        readonly textfieldSize: "s";
+    } | {
+        readonly cellVerticalPadding: 7;
+        readonly cellHorizontalPadding: 8;
+        readonly textfieldSize: "s";
+    } | {
+        readonly cellVerticalPadding: 4;
+        readonly cellHorizontalPadding: 4;
+        readonly textfieldSize: "xs";
+    };
+};

package/components/TableGlide/theming/types.d.ts

@@ -0,0 +1,23 @@
+import { ThemeCustoms } from './custom-colors';
+import { GlideSizeConfig, SIZE } from '../constants';
+import { Theme as ThemeGlide } from '@glideappsfinal/glide-data-grid';
+
+export type ThemeDynamicCustoms = {
+    rowSize: SIZE;
+    activeSizes: GlideSizeConfig;
+};
+export type Theme = ThemeGlide & ThemeCustoms & ThemeDynamicCustoms;
+export type GlideThemePartial = Partial<Theme>;
+export interface GlideThemeForRender extends GlideThemePartial {
+    accentColor: string;
+    accentLight?: string;
+    accentFg?: string;
+    bgCell: string;
+    bgHeader?: string;
+    borderColor: string;
+    textLight: string;
+    textDark: string;
+    textMedium?: string;
+    baseFontFull: string;
+    cellHorizontalPadding?: number;
+}

package/components/TableGlide/tokens.d.ts

@@ -0,0 +1,109 @@
+import { ActiveTheme } from './theming/activeTheme.type';
+
+declare const TOKENS_LIGHT: {
+    readonly textPrimary: "#13181BF5";
+    readonly textPrimaryHover: "#13181B93";
+    readonly textPrimaryActive: "#13181BC4";
+    readonly textSecondary: "#485056B0";
+    readonly textSecondaryHover: "#485056FF";
+    readonly textSecondaryActive: "#485056D3";
+    readonly textTertiary: "#707C847A";
+    readonly textTertiaryHover: "#717C84FF";
+    readonly textTertiaryActive: "#717C8493";
+    readonly textTertiaryBase: "#8A959D";
+    readonly textTertiaryVariant: "#657179";
+    readonly textParagraph: "#13181BCC";
+    readonly textParagraphHover: "#13181B7A";
+    readonly textParagraphActive: "#13181BA3";
+    readonly textAccent: "#0B7ECB";
+    readonly textAccentHover: "#0D96F2FF";
+    readonly textAccentActive: "#0966A5FF";
+    readonly textAccentTransparent20: "#0B7ECB33";
+    readonly textPositive: "#108E26";
+    readonly textPositiveHover: "#14B32EFF";
+    readonly textPositiveActive: "#0C6A1BFF";
+    readonly textWarning: "#FA5F05";
+    readonly textWarningHover: "#FB782DFF";
+    readonly textWarningActive: "#D25004FF";
+    readonly textNegative: "#E31227";
+    readonly textNegativeHover: "#EE2F43FF";
+    readonly textNegativeActive: "#BD0F21FF";
+    readonly inverseTextPrimary: "#F2F5F8F5";
+    readonly onDarkTextPrimary: "#F2F5F8F5";
+    readonly onDarkTextPrimaryHover: "#F2F5F893";
+    readonly onDarkTextPrimaryActive: "#F2F5F8C4";
+    readonly onDarkTextPrimary96: "#F7F9FBF4";
+    readonly onDarkTextPrimary56: "#F7F9FB8E";
+    readonly onDarkTextPrimary28: "#F7F9FB47";
+    readonly onLightTextPrimary: "#13181BF5";
+    readonly onLightTextPrimaryHover: "#13181B93";
+    readonly onLightTextPrimaryActive: "#13181BC4";
+    readonly surfaceSolidCard: "#FFFFFF";
+    readonly surfaceAccentMinor: "#ECF6FCFF";
+    readonly surfaceSolidDefault: "#060A0C";
+    readonly surfaceSolidTertiary: "#E8EEF2";
+    readonly surfaceAccent: "#118CDF";
+    readonly surfaceAccentHover: "#1798EEFF";
+    readonly surfaceAccentActive: "#0F81CCFF";
+    readonly surfaceTransparentSecondary: "#ADB9C238";
+    readonly surfaceTransparentSecondaryHover: "#ADB9C247";
+    readonly surfaceTransparentSecondaryActive: "#ADB9C24D";
+    readonly surfaceTransparentTertiary: "#8A959D47";
+    readonly surfaceTransparentDeep: "#30373CC6";
+    readonly surfaceClear: "#FFFFFF00";
+    readonly surfacePositive: "#1A9E32";
+    readonly surfacePositiveHover: "#1EB83AFF";
+    readonly surfacePositiveActive: "#178C2CFF";
+    readonly surfaceWarning: "#FA5F05";
+    readonly surfaceWarningHover: "#FB782DFF";
+    readonly surfaceWarningActive: "#E65705FF";
+    readonly surfaceWarningMinor56: "#F3A9128E";
+    readonly surfaceNegative: "#FF293E";
+    readonly surfaceNegativeHover: "#FF5263FF";
+    readonly surfaceNegativeActive: "#FF142CFF";
+    readonly disabled: "#DDDDDD";
+    readonly surfaceTransparentAccent: "#118CDF1F";
+    readonly surfaceTransparentAccent12: "#118CDF1E";
+    readonly surfaceTransparentAccent20: "#118CDF33";
+    readonly surfaceTransparentPositive: "#1A9E321F";
+    readonly surfaceTransparentPositive12: "#1A9E321E";
+    readonly surfaceTransparentPositive20: "#1A9E3233";
+    readonly surfaceTransparentWarning: "#FA5F051F";
+    readonly surfaceTransparentWarning12: "#FA5F051E";
+    readonly surfaceTransparentWarning20: "#FA5F0533";
+    readonly surfaceTransparentNegative: "#FF293E1F";
+    readonly surfaceTransparentNegative12: "#FF293E1E";
+    readonly surfaceTransparentNegative20: "#FF293E33";
+    readonly onLightSurfaceSolidDefault: "#060A0C";
+    readonly onLightSurfaceTransparentDeep: "#30373CC7";
+    readonly onDarkSurfaceSolidDefault: "#F7F9FB";
+    readonly onDarkSurfaceTransparentCard: "#FFFFFF0F";
+    readonly outlineAccent: "#0B7ECB";
+    readonly outlineSolidPrimary: "#D5DFE6";
+    readonly outlineSolidPrimary26: "#D5DFE642";
+    readonly dataBlueMinor: "#CFECFF";
+    readonly dataBlueMinorActive: "#C2E7FFFF";
+    readonly dataBlue: "#8BB2FC";
+    readonly dataAccentMinorHover: "#52BAFF";
+    readonly dataPositive: "#28D247";
+    readonly dataPositiveMinor: "#9EFAAF";
+    readonly dataNegative: "#FF8F9A";
+    readonly dataNegativeMinor: "#FFE0E3";
+    readonly dataWarning: "#FD9C68";
+    readonly dataWarningMinor: "#FEE2D2";
+    readonly dataOrange: "#F3A912";
+    readonly dataOrangeMinor: "#FFD37A";
+    readonly dataViolet: "#AD42F5";
+    readonly dataVioletMinor: "#DEB7F7";
+    readonly dataPink: "#FF8FBC";
+    readonly dataMagenta: "#F391E2";
+    readonly dataCyan: "#00DDE0";
+    readonly dataCyanDark: "#04C6C9";
+    readonly dataLime: "#93E006";
+    readonly dataTeal: "#14CC98";
+};
+export type Tokens = {
+    [K in keyof typeof TOKENS_LIGHT]: string;
+};
+export declare const getTokens: (activeTheme?: ActiveTheme) => Tokens;
+export {};

package/components/TableGlide/types.d.ts

@@ -0,0 +1,189 @@
+import { ActiveTheme } from './theming/activeTheme.type';
+import { GlideThemeForRender, GlideThemePartial, Theme } from './theming/types';
+import { CanvasNodeTooltipConfig } from './lib/canvas';
+import { GlideSizeConfig, SIZE } from './constants';
+import { CSSProperties, ComponentProps, ReactElement, ReactNode, ReactPortal, Ref, RefObject } from 'react';
+import { DataEditor, DataEditorRef, GridCell, GridColumn, GridSelection, ProvideEditorCallback, ProvideEditorCallbackResult, ProvideEditorComponent } from '@glideappsfinal/glide-data-grid';
+
+export type { Tokens } from './tokens';
+export type { DataEditor, DataEditorRef, GridCell, GridColumn, ProvideEditorCallback, ProvideEditorCallbackResult, ProvideEditorComponent, };
+export type ThemeDynamicCustoms = {
+    rowSize: SIZE;
+    activeSizes: GlideSizeConfig;
+};
+export type { Theme, ActiveTheme };
+export type GlideProps = ComponentProps<typeof DataEditor>;
+export type RowHeightGlide = GlideProps['rowHeight'];
+export type HighlightActiveType = 'cell' | 'row' | 'range-cell' | 'disabled';
+export type CellsSelectionMode = 'cell' | 'range-cell' | 'multi-range-cell' | 'disabled';
+export type HoverEffectsConfig = {
+    row?: boolean | {
+        color?: string;
+    };
+};
+export type ObjectForExtending = Record<string, any>;
+export interface CanvasCellOptions<R extends ObjectForExtending = ObjectForExtending, SR = unknown> {
+    render: (ctx: CanvasRenderingContext2D, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, theme: GlideThemeForRender, hoverX: number | undefined, hoverY: number | undefined, row: R, rowIndex: number) => {
+        hoveredAreas?: Array<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+    };
+    onClick?: (x: number, y: number, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, rowInfo: CellInfo<R, SR>, renderData?: {
+        hoveredAreas?: Array<{
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }>;
+    }) => boolean;
+    onMouseEnter?: (rowInfo: CellInfo<R, SR>) => void;
+    onMouseLeave?: (rowInfo: CellInfo<R, SR>) => void;
+    copyData?: string | ((row: R) => string);
+    getCacheKey?: (rowInfo: CellInfo<R, SR>) => string | number | boolean | null | undefined;
+}
+export type CanvasEl = ReactElement;
+export type CanvasContent = ReactElement | string;
+export type CellContent = CanvasContent | GridCell;
+export type CellThemeOverrideResult = Partial<{
+    bgCell: string;
+    cellHorizontalPadding: number;
+    cellVerticalPadding: number;
+}>;
+export type СolumnGlide = GlideProps['columns'][number];
+export type CellHoverState = {
+    cellHover: boolean;
+    rowHover: boolean;
+};
+export type CellActiveState = {
+    cellActive: boolean;
+    rowActive: boolean;
+};
+export type CellInfo<R extends ObjectForExtending, SR = unknown> = {
+    row: R;
+    column: ColumnGlideLast<R, SR>;
+    colInd: number;
+    rowInd: number;
+    ctxs: ObjectForExtending;
+    theme: Theme;
+    hovered: CellHoverState;
+    active: CellActiveState;
+};
+export type EditingCellInfoGlide<R extends ObjectForExtending, SR = unknown> = Omit<CellInfo<R, SR>, 'hovered' | 'active'> & {
+    onRowChange: (row: R, commitChanges?: boolean) => void;
+    onClose: (commitChanges?: boolean, shouldFocusCell?: boolean) => void;
+};
+export type SummaryCellInfo<R extends ObjectForExtending, SR> = {
+    row: SR;
+    column: ColumnGlideLast<R, SR>;
+    colInd: number;
+    rowInd: number;
+    ctxs: ObjectForExtending;
+    theme: Theme;
+};
+type DrawHeaderArgs = Parameters<NonNullable<GlideProps['drawHeader']>>[0];
+export type HeaderCellInfo<R extends ObjectForExtending, SR> = {
+    column: ColumnGlideLast<R, SR>;
+    drawArgs: DrawHeaderArgs;
+    ctxs: ObjectForExtending;
+    theme: Theme;
+};
+export type ColSpan<R extends ObjectForExtending, SR> = number | ((cellInfo: CellInfo<R, SR>) => number);
+export type ColumnGlideGetCellContent<R extends ObjectForExtending, SR> = (cellInfo: CellInfo<R, SR>) => CellContent;
+export type ColumnGlideGetSummaryCellContent<R extends ObjectForExtending, SR> = (cellInfo: CellInfo<R, SR>) => CellContent;
+export type ColumnGlideCustoms<R extends ObjectForExtending, SR = unknown> = {
+    id: string;
+    isServiceColumn?: boolean;
+    isErrorCell?: (row: R) => boolean;
+    renderHeaderCell?: (cellInfo: HeaderCellInfo<R, SR>) => CanvasContent;
+    copyData?: string | ((row: R) => string);
+    editable?: boolean | ((row: R) => boolean);
+    contentAlign?: 'right' | 'left' | 'center';
+    renderCell?: ColumnGlideGetCellContent<R, SR>;
+    renderEditCell?: (cellInfo: EditingCellInfoGlide<R, SR>) => CellContent;
+    renderSummaryCell?: (summaryCellInfo: SummaryCellInfo<R, SR>) => CellContent;
+    colSpan?: ColSpan<R, SR>;
+    cellTooltip?: CanvasNodeTooltipConfig | ((context: {
+        row: R;
+        column: ColumnGlideLast<R, SR>;
+        ctxs: ObjectForExtending;
+        refTable?: Ref<DataEditorRef>;
+        colInd?: number;
+        rowInd?: number;
+        theme?: Theme;
+    }) => CanvasNodeTooltipConfig | null);
+    headerCellTooltip?: CanvasNodeTooltipConfig | ((context: {
+        column: ColumnGlideLast<R, SR>;
+        ctxs: ObjectForExtending;
+        refTable?: Ref<DataEditorRef>;
+        colInd?: number;
+        theme?: Theme;
+    }) => CanvasNodeTooltipConfig | null);
+    columnThemeOverride?: (cellInfo: CellInfo<R, SR>) => CellThemeOverrideResult | undefined;
+    hasPreview?: boolean | 'none';
+    minWidth?: number;
+    maxWidth?: number;
+};
+export type ColumnGlideLast<R extends ObjectForExtending, SR> = СolumnGlide & ColumnGlideCustoms<R, SR>;
+export type { GlideThemeForRender, GlideThemePartial };
+export type RenderGroupHeaderArgs = Parameters<NonNullable<GlideProps['drawGroupHeader']>>[0];
+export type TableGlideCustomProps<R extends ObjectForExtending, SR = unknown> = {
+    columns: ColumnGlideLast<R, SR>[];
+    rows: readonly R[];
+    bottomSummaryRows?: readonly SR[];
+    rowSize?: SIZE;
+    rowHeight?: ((row: R, currentRowSize: {
+        rowSizeName: SIZE;
+        rowSizeValue: number;
+    }, rowIndex: number) => number) | number | undefined | null;
+    ctxs?: ObjectForExtending;
+    renderGroupHeader?: (args: RenderGroupHeaderArgs) => 'default' | {
+        defaultWithCustomGroupName: string;
+    } | CanvasEl;
+    refTable?: Ref<DataEditorRef>;
+    onColumnsReorder?: (sourceKey: string, targetKey: string) => void;
+    portalEventTargetRef?: RefObject<HTMLElement | null>;
+    unstickyHeader?: boolean;
+    resizableColumn?: boolean;
+    containerRef?: Ref<HTMLDivElement>;
+    containerClassName?: string;
+    containerStyle?: CSSProperties;
+    renderOverlayFeatures?: (ctx: {
+        containerElement: HTMLDivElement;
+        renderInContainer: (children: ReactNode) => ReactPortal | null;
+    }) => ReactNode;
+    hideGrid?: boolean;
+    contentStateNode?: ReactNode;
+    fullScreened?: boolean;
+    editorOverlayPortal?: 'inside';
+    groupHeaderHeight?: number[];
+    highlightActiveType?: HighlightActiveType;
+    cellsSelectionMode?: CellsSelectionMode;
+    onSelectionEmit?: (selection: GridSelection) => void;
+    onColumnSelectionChange?: (selectedColumnKeys: string[]) => void;
+    pendingColumnSelectionKeys?: string[] | null;
+    onColumnSelectionApplied?: () => void;
+    highlightActiveRow?: number;
+    onHighlightActiveRowChange?: (row: number | undefined, rowData?: R | undefined) => void;
+    highlightActiveRowControlled?: boolean;
+    enableColumnSelection?: boolean;
+    enableRowSelection?: boolean;
+    enableSelectAll?: boolean;
+    checkboxSelectedRowIndexes?: ReadonlySet<number>;
+    checkboxVisibleRowIndexes?: ReadonlySet<number>;
+    hoverEffects?: HoverEffectsConfig;
+    enableLowDprHairline?: boolean;
+};
+export type TableGlideProps<R extends ObjectForExtending, SR> = Omit<GlideProps, keyof TableGlideCustomProps<R, SR> | 'getCellContent' | 'drawGroupHeader' | 'ref' | 'groupHeaderHeight'> & TableGlideCustomProps<R, SR>;

package/components/TableGlide/utils/cellAnimations.d.ts

@@ -0,0 +1,11 @@
+import { DrawArgs, InnerGridCell } from '@glideappsfinal/glide-data-grid';
+
+export type AnimationEasing = (t: number) => number;
+export interface NumericAnimationOptions {
+    duration?: number;
+    easing?: AnimationEasing;
+    initialValue?: number;
+}
+export declare const easeOutCubic: AnimationEasing;
+export declare const easeInOutCubic: AnimationEasing;
+export declare function animateNumericValue<T extends InnerGridCell>(args: DrawArgs<T>, cellIdentity: string, animationKey: string, targetValue: number, options?: NumericAnimationOptions): number;

package/components/TableGlide/utils/createCell.d.ts

@@ -0,0 +1,10 @@
+import { TextCell } from '@glideappsfinal/glide-data-grid';
+
+export declare const DEFAULT_ROW_HEIGHT = 33;
+export declare const EMPTY_CELL_OBJ: TextCell;
+export type TextCellOptions = Omit<TextCell, 'kind' | 'allowOverlay' | 'displayData' | 'data'> & {
+    data?: string;
+    allowOverlay?: boolean;
+};
+export declare const createTextCellGlide: (displayData: string, options?: TextCellOptions) => TextCell;
+export declare const createEmptyCellGlide: (options?: TextCellOptions) => TextCell;

package/components/TableGlide/utils/getFixedPositionOffset.d.ts

@@ -0,0 +1,4 @@
+export declare function getFixedPositionOffset(element: HTMLElement): {
+    x: number;
+    y: number;
+};

package/components/TableGlide/utils/getScrollbarWidth.d.ts

@@ -0,0 +1 @@
+export declare function getScrollbarWidth(): number;

package/components/TableGlide/utils/getSpan.d.ts

@@ -0,0 +1,3 @@
+import { CellInfo, ColSpan, ObjectForExtending } from '../types';
+
+export declare const getSpan: <R extends ObjectForExtending, SR = unknown>(colSpan: ColSpan<R, SR> | null | undefined, cellInfo: CellInfo<R, SR>) => readonly [number, number] | null;

package/components/TableGlide/utils/gridCell.d.ts

@@ -0,0 +1,3 @@
+import { GridCell } from '@glideappsfinal/glide-data-grid';
+
+export declare function getGridCellDisplayText(cell: GridCell): string;

package/components/TableGlide/utils/queryGlideElements.d.ts

@@ -0,0 +1,5 @@
+export declare function queryGlideElements(wrapper: HTMLElement | null | undefined): {
+    container: HTMLDivElement | null;
+    scroller: HTMLDivElement | null;
+    underlay: HTMLDivElement | null;
+};

package/components/TableGlide/utils/typeGuards.d.ts

@@ -0,0 +1,11 @@
+import { CanvasEl, CellContent } from '../types';
+import { GridCell } from '@glideappsfinal/glide-data-grid';
+
+export declare function isGlideGridCellObj(cell: CellContent): cell is GridCell;
+export declare function isObject(value: unknown): boolean;
+export declare function isPrimitive(value: unknown): value is number | string | boolean | null | undefined;
+export declare function isValueEmpty(value: unknown): value is boolean | null | undefined;
+export declare const isCanvasEl: (element: unknown) => element is CanvasEl;
+export declare const isCanvasString: (element: unknown) => element is string;
+export declare const isCanvasContent: (element: unknown) => element is string | CanvasEl;
+export declare const isGlideCellObj: (element: unknown) => element is GridCell;

package/components/TableSDDS/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("@salutejs/sdds-finai");Object.defineProperty(exports,"TableSDDS",{enumerable:!0,get:()=>e.Table});