@daisforge/ui 1.10.3

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

@@ -0,0 +1,12 @@
+export type { ButtonSize, ButtonView, SizeConfig, ViewColors } from './buttons';
+export { BUTTON_PADDING_Y, drawButton, drawButtonWithView, drawIcon, drawIconButton, drawIconButtonWithView, ICON_SIZE_ADJUSTMENT, SIZE_CONFIG, VIEW_COLORS, } from './buttons';
+export { CellCanvasRoot } from './CellCanvasRoot';
+export { createCanvasCell, isCanvasCell } from './factory';
+export { buildCellId, getCellIndices, isHoveringBounds, isPointInArea, normalizeHoverPoint, resolveClickPoint, toRelativePoint, } from './helpers';
+export type { ButtonIcon, IconDefinition, IconLoadCallback, IconSpriteOptions, IconSpriteStats, } from './iconSprites';
+export { drawIcon as drawIconDirect, getIconImageDirect, getIconSprite, getIconSpriteStats, onAnyIconLoad, preloadIconSprites, registerIconDefinitions, resetIconSpriteCache, } from './iconSprites';
+export type { CanvasCellRendererConfig, CanvasClickDispatchResult, CanvasPointerIntentResult, } from './renderer';
+export { canvasCellRenderer, createCanvasCellRenderer, performCanvasClick, performCanvasPointerDownIntent, } from './renderer';
+export { getHoverState, retrieveRenderData, storeRenderData, updateHoverState, } from './state';
+export type { CanvasCell, CanvasCellData, CanvasRenderResult, CellIndices, HoverMeta, HoverState, Point, RectBounds, RenderClickHandler, } from './types';
+export { CANVAS_CELL_KIND } from './types';

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

@@ -0,0 +1,39 @@
+import { Y as s, a$ as t, b0 as n, ae as r, ah as o, ai as i, b1 as I, aP as c, b2 as l, aQ as C, an as d, ao as b, aq as v, ar as S, as as D, H as p, b3 as w, b4 as g, M as N, N as _, O as u, b5 as P, b6 as R, b7 as A, b8 as B, U as O, aY as m, aZ as E, V as H, W as V, X as f, b9 as h, ba as L, bb as T, bc as W, bd as U } from "../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  s as BUTTON_PADDING_Y,
+  t as CANVAS_CELL_KIND,
+  n as CellCanvasRoot,
+  r as ICON_SIZE_ADJUSTMENT,
+  o as SIZE_CONFIG,
+  i as VIEW_COLORS,
+  I as buildCellId,
+  c as canvasCellRenderer,
+  l as createCanvasCell,
+  C as createCanvasCellRenderer,
+  d as drawButton,
+  b as drawButtonWithView,
+  v as drawIcon,
+  S as drawIconButton,
+  D as drawIconButtonWithView,
+  p as drawIconDirect,
+  w as getCellIndices,
+  g as getHoverState,
+  N as getIconImageDirect,
+  _ as getIconSprite,
+  u as getIconSpriteStats,
+  P as isCanvasCell,
+  R as isHoveringBounds,
+  A as isPointInArea,
+  B as normalizeHoverPoint,
+  O as onAnyIconLoad,
+  m as performCanvasClick,
+  E as performCanvasPointerDownIntent,
+  H as preloadIconSprites,
+  V as registerIconDefinitions,
+  f as resetIconSpriteCache,
+  h as resolveClickPoint,
+  L as retrieveRenderData,
+  T as storeRenderData,
+  W as toRelativePoint,
+  U as updateHoverState
+};

package/components/TableGlide/lib/canvas/cells/renderer/canvasCellRenderer.d.ts

@@ -0,0 +1,11 @@
+import { CanvasCellRendererConfig } from './types';
+import { CanvasClickDispatchResult } from './performCanvasClick';
+import { BeginInteractionSessionArgs, FindInteractionSessionArgs, InteractionSession } from '../../interaction/interactionSessionStore';
+
+interface CanvasCellRendererOptions {
+    beginOrGetInteractionSession?: (args: BeginInteractionSessionArgs) => InteractionSession;
+    consumeCanvasClickResult?: (args: FindInteractionSessionArgs) => CanvasClickDispatchResult | undefined;
+}
+export declare function createCanvasCellRenderer(options?: CanvasCellRendererOptions): CanvasCellRendererConfig;
+export declare const canvasCellRenderer: CanvasCellRendererConfig;
+export {};

package/components/TableGlide/lib/canvas/cells/renderer/clickHandlers.d.ts

@@ -0,0 +1,11 @@
+import { CanvasCell, RectBounds } from '../types';
+import { retrieveRenderData } from '../state';
+import { toRelativePoint } from '../helpers';
+import { CellCanvasPointerDispatchResult } from '../CellCanvasRoot';
+
+type RenderData = ReturnType<typeof retrieveRenderData>;
+type RelativePoint = ReturnType<typeof toRelativePoint>;
+export declare function handleCanvasRootClick(renderData: RenderData, relativePoint: RelativePoint, event: MouseEvent | React.MouseEvent | undefined): CellCanvasPointerDispatchResult;
+export declare function handleClickHandlers(renderData: RenderData, relativePoint: RelativePoint): boolean;
+export declare function handleCellClick(cell: CanvasCell, relativePoint: RelativePoint, rect: RectBounds, row: Record<string, unknown> | undefined, rowIndex: number, renderData: RenderData): boolean;
+export {};

package/components/TableGlide/lib/canvas/cells/renderer/constants.d.ts

@@ -0,0 +1,6 @@
+import { PointerKeyPair } from './types';
+
+export declare const RELATIVE_COORD_TOLERANCE = 5;
+export declare const POINTER_CANDIDATE_KEYS: PointerKeyPair[];
+export declare const DEFAULT_CURSOR = "default";
+export declare const LEGACY_HOVER_CURSOR = "pointer";

package/components/TableGlide/lib/canvas/cells/renderer/hoverHandlers.d.ts

@@ -0,0 +1,5 @@
+import { RelativePoint, RendererDrawArgs } from './types';
+import { CanvasCellData, CanvasRenderArgs, CanvasRenderResult, RectBounds } from '../types';
+
+export declare function handleCanvasRootHover(canvasRoot: CanvasRenderResult['canvasRoot'] | undefined, relativeHover: RelativePoint | undefined, argsAny: CanvasRenderArgs, args: RendererDrawArgs): void;
+export declare function updateHoverStateIfNeeded(cellData: CanvasCellData, relativeHover: RelativePoint | undefined, hoveredAreas: RectBounds[], canvasRoot: CanvasRenderResult['canvasRoot'] | undefined, args: RendererDrawArgs): void;

package/components/TableGlide/lib/canvas/cells/renderer/index.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.DEFAULT_CURSOR=e.DEFAULT_CURSOR;exports.LEGACY_HOVER_CURSOR=e.LEGACY_HOVER_CURSOR;exports.POINTER_CANDIDATE_KEYS=e.POINTER_CANDIDATE_KEYS;exports.RELATIVE_COORD_TOLERANCE=e.RELATIVE_COORD_TOLERANCE;exports.canvasCellRenderer=e.canvasCellRenderer;exports.createCanvasCellRenderer=e.createCanvasCellRenderer;exports.getRelativePointerPosition=e.getRelativePointerPosition;exports.handleCanvasRootClick=e.handleCanvasRootClick;exports.handleCanvasRootHover=e.handleCanvasRootHover;exports.handleCellClick=e.handleCellClick;exports.handleClickHandlers=e.handleClickHandlers;exports.isAbsoluteCoords=e.isAbsoluteCoords;exports.isRelativeCoords=e.isRelativeCoords;exports.performCanvasClick=e.performCanvasClick;exports.performCanvasPointerDownIntent=e.performCanvasPointerDownIntent;exports.updateHoverStateIfNeeded=e.updateHoverStateIfNeeded;

package/components/TableGlide/lib/canvas/cells/renderer/index.d.ts

@@ -0,0 +1,10 @@
+export type { CanvasCellRendererConfig, CursorType, PointerKeyPair, PointerKeyX, PointerKeyY, RendererSelectArgs, RelativePoint, RendererClickArgs, RendererDrawArgs, } from './types';
+export type { CanvasClickDispatchResult } from './performCanvasClick';
+export type { CanvasPointerIntentResult } from './performCanvasPointerDownIntent';
+export { DEFAULT_CURSOR, LEGACY_HOVER_CURSOR, POINTER_CANDIDATE_KEYS, RELATIVE_COORD_TOLERANCE, } from './constants';
+export { getRelativePointerPosition, isAbsoluteCoords, isRelativeCoords, } from './pointerUtils';
+export { handleCanvasRootClick, handleCellClick, handleClickHandlers, } from './clickHandlers';
+export { handleCanvasRootHover, updateHoverStateIfNeeded, } from './hoverHandlers';
+export { performCanvasClick } from './performCanvasClick';
+export { performCanvasPointerDownIntent } from './performCanvasPointerDownIntent';
+export { canvasCellRenderer, createCanvasCellRenderer, } from './canvasCellRenderer';

package/components/TableGlide/lib/canvas/cells/renderer/index.mjs

@@ -0,0 +1,19 @@
+import { aL as s, aM as o, aN as C, aO as n, aP as l, aQ as r, aR as t, aS as R, aT as d, aU as i, aV as v, aW as E, aX as O, aY as _, aZ as A, a_ as c } from "../../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  s as DEFAULT_CURSOR,
+  o as LEGACY_HOVER_CURSOR,
+  C as POINTER_CANDIDATE_KEYS,
+  n as RELATIVE_COORD_TOLERANCE,
+  l as canvasCellRenderer,
+  r as createCanvasCellRenderer,
+  t as getRelativePointerPosition,
+  R as handleCanvasRootClick,
+  d as handleCanvasRootHover,
+  i as handleCellClick,
+  v as handleClickHandlers,
+  E as isAbsoluteCoords,
+  O as isRelativeCoords,
+  _ as performCanvasClick,
+  A as performCanvasPointerDownIntent,
+  c as updateHoverStateIfNeeded
+};

package/components/TableGlide/lib/canvas/cells/renderer/performCanvasClick.d.ts

@@ -0,0 +1,19 @@
+import { CanvasCell, CanvasRenderResult, RectBounds } from '../types';
+import { RelativePoint } from './types';
+
+export interface CanvasClickDispatchResult {
+    handled: boolean;
+    propagationStopped: boolean;
+    suppressGridDefault: boolean;
+}
+interface PerformCanvasClickArgs {
+    cell: CanvasCell;
+    rect: RectBounds;
+    relativePoint: RelativePoint;
+    renderData: CanvasRenderResult | undefined;
+    rowData?: Record<string, unknown>;
+    rowIndex: number;
+    event?: MouseEvent | React.MouseEvent;
+}
+export declare function performCanvasClick({ cell, rect, relativePoint, renderData, rowData, rowIndex, event, }: PerformCanvasClickArgs): CanvasClickDispatchResult;
+export {};

package/components/TableGlide/lib/canvas/cells/renderer/performCanvasPointerDownIntent.d.ts

@@ -0,0 +1,13 @@
+import { RelativePoint } from './types';
+import { CanvasRenderResult } from '../types';
+import { ResolvedCanvasInteractionConfig } from '../../core/canvasInteraction';
+
+export interface CanvasPointerIntentResult {
+    handled: boolean;
+    suppressEarlyGridSelect: boolean;
+    interaction?: ResolvedCanvasInteractionConfig;
+}
+export declare function performCanvasPointerDownIntent({ renderData, relativePoint, }: {
+    renderData: CanvasRenderResult | undefined;
+    relativePoint: RelativePoint;
+}): CanvasPointerIntentResult;

package/components/TableGlide/lib/canvas/cells/renderer/pointerUtils.d.ts

@@ -0,0 +1,6 @@
+import { RelativePoint } from './types';
+import { CanvasRenderArgs, RectBounds } from '../types';
+
+export declare function getRelativePointerPosition(argsAny: CanvasRenderArgs, rect: RectBounds): RelativePoint | undefined;
+export declare function isAbsoluteCoords(x: number, y: number, rect: RectBounds): boolean;
+export declare function isRelativeCoords(x: number, y: number, rect: RectBounds): boolean;

package/components/TableGlide/lib/canvas/cells/renderer/types.d.ts

@@ -0,0 +1,58 @@
+import { CanvasCell, RectBounds } from '../types';
+import { GlideThemeForRender } from '../../../../theming/types';
+import { GridCellKind } from '@glideappsfinal/glide-data-grid';
+
+export type PointerKeyX = 'hoverX' | 'mouseX' | 'pointerX' | 'posX' | 'x';
+export type PointerKeyY = 'hoverY' | 'mouseY' | 'pointerY' | 'posY' | 'y';
+export type PointerKeyPair = [PointerKeyX, PointerKeyY];
+export interface RelativePoint {
+    x: number;
+    y: number;
+}
+export interface RendererDrawArgs {
+    ctx: CanvasRenderingContext2D;
+    rect: RectBounds;
+    theme: GlideThemeForRender;
+    cellFillColor?: string;
+    cell: CanvasCell;
+    bounds: RectBounds;
+    overrideCursor?: (cursor: CursorType) => void;
+    hoverX?: number;
+    hoverY?: number;
+    row?: Record<string, unknown>;
+    rowData?: Record<string, unknown>;
+    event?: MouseEvent | React.MouseEvent;
+    frameTime?: number;
+    requestAnimationFrame?: () => void;
+}
+export interface RendererClickArgs {
+    cell: CanvasCell;
+    bounds: RectBounds;
+    posX?: number;
+    posY?: number;
+    x?: number;
+    y?: number;
+    location?: [number, number];
+    button?: number;
+    isDoubleClick?: boolean;
+    event?: MouseEvent | React.MouseEvent;
+    row?: Record<string, unknown>;
+    rowData?: Record<string, unknown>;
+    preventDefault?: () => void;
+}
+export type RendererSelectArgs = RendererClickArgs;
+export type CursorType = 'default' | 'pointer' | 'text' | 'move' | 'grab' | 'grabbing' | 'not-allowed' | 'crosshair';
+export interface CanvasCellRendererConfig {
+    kind: typeof GridCellKind.Custom;
+    isMatch: (cell: {
+        data?: {
+            kind?: string;
+        };
+    }) => cell is CanvasCell;
+    needsHover: boolean;
+    needsHoverPosition: boolean;
+    onSelect?: (args: RendererSelectArgs) => void;
+    onClick: (args: RendererClickArgs) => CanvasCell | undefined;
+    draw: (args: RendererDrawArgs, cell: CanvasCell) => void;
+    onPaste: () => undefined;
+}

package/components/TableGlide/lib/canvas/cells/renderer.d.ts

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

package/components/TableGlide/lib/canvas/cells/state.d.ts

@@ -0,0 +1,6 @@
+import { CanvasCell, CanvasCellData, CanvasRenderResult } from './types';
+
+export declare function storeRenderData(cellId: string, cell: CanvasCell, renderResult?: CanvasRenderResult): CanvasRenderResult;
+export declare function retrieveRenderData(cellId: string, cell: CanvasCell): CanvasRenderResult | undefined;
+export declare function updateHoverState(cellData: CanvasCellData, isHovered: boolean): void;
+export declare function getHoverState(cellData: CanvasCellData): boolean | undefined;

package/components/TableGlide/lib/canvas/cells/types.d.ts

@@ -0,0 +1,71 @@
+import { CellCanvasRoot } from './CellCanvasRoot';
+import { GlideThemeForRender } from '../../../theming/types';
+import { GridCellKind } from '@glideappsfinal/glide-data-grid';
+
+export declare const CANVAS_CELL_KIND = "canvas-cell";
+export type RectBounds = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export type CellIndices = {
+    colIndex: number;
+    rowIndex: number;
+};
+export type HoverMeta = {
+    hoverX?: number;
+    hoverY?: number;
+    rectX: number;
+    rectY: number;
+};
+export type HoverState = boolean | HoverMeta;
+export type RenderClickHandler = {
+    area: RectBounds;
+    handler: () => void;
+};
+export type CanvasRenderResult = {
+    hoveredAreas?: RectBounds[];
+    clickHandlers?: RenderClickHandler[];
+    preferredHeight?: number;
+    canvasRoot?: CellCanvasRoot;
+};
+export interface CanvasRenderArgs {
+    canvasRoot?: CellCanvasRoot;
+    row?: Record<string, unknown>;
+    rowData?: Record<string, unknown>;
+    event?: MouseEvent | React.MouseEvent;
+    hoverX?: number;
+    hoverY?: number;
+    mouseX?: number;
+    mouseY?: number;
+    pointerX?: number;
+    pointerY?: number;
+    posX?: number;
+    posY?: number;
+    x?: number;
+    y?: number;
+    frameTime?: number;
+    requestAnimationFrame?: () => void;
+    drawState?: [unknown, (state: unknown) => void];
+}
+export interface CanvasCellData {
+    kind: typeof CANVAS_CELL_KIND;
+    render: (ctx: CanvasRenderingContext2D, rect: RectBounds, theme: GlideThemeForRender, hoverX: number | undefined, hoverY: number | undefined, args?: CanvasRenderArgs) => CanvasRenderResult;
+    onClick?: (x: number, y: number, rect: RectBounds, row?: Record<string, unknown>, rowIndex?: number, renderData?: CanvasRenderResult) => boolean;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    copyData?: string;
+    renderData?: CanvasRenderResult;
+}
+export interface CanvasCell {
+    kind: typeof GridCellKind.Custom;
+    allowOverlay: boolean;
+    readonly: boolean;
+    copyData: string;
+    data: CanvasCellData;
+}

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

@@ -0,0 +1,249 @@
+import { normalizeIcon } from '../utils/iconUtils';
+import { CanvasLink, LinkView } from '../primitives/CanvasLink';
+import { CanvasTextOptions } from '../primitives/CanvasText';
+import { CanvasIconButton } from '../primitives/CanvasIconButton';
+import { CanvasIcon } from '../primitives/CanvasIcon';
+import { CanvasEmbedIconButton } from '../primitives/CanvasEmbedIconButton';
+import { CanvasButton } from '../primitives/CanvasButton';
+import { BadgeSize, BadgeView } from '../primitives/CanvasBadge';
+import { CanvasNodeTooltipConfig } from '../utils/portalHoverEvents';
+import { FlexBoxOptions } from '../miniflex';
+import { CanvasEvent, CanvasFlexStyle, CanvasNode, PositionValue } from '../core/CanvasNode';
+import { CanvasInteractionConfig } from '../core/canvasInteraction';
+import { CanvasContainer } from '../core/CanvasContainer';
+import { ButtonIcon } from '../cells/iconSprites';
+import { ButtonSize, ButtonView, EmbedIconButtonSize, GlideThemeForRender } from '../cells/buttons';
+import { default as React, ReactElement, ReactNode } from 'react';
+
+interface CanvasInteractionProps {
+    interaction?: CanvasInteractionConfig;
+}
+interface CanvasLayerProps {
+    zIndex?: number;
+}
+interface ContainerProps extends CanvasInteractionProps, CanvasLayerProps, Omit<FlexBoxOptions, 'columnGap' | 'rowGap'> {
+    children?: ReactNode;
+    style?: Partial<CanvasFlexStyle>;
+    backgroundColor?: string;
+    id?: string;
+    gap?: number;
+    columnGap?: number;
+    rowGap?: number;
+    portalHoverEnabled?: boolean;
+    position?: 'relative' | 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    tooltip?: CanvasNodeTooltipConfig;
+    onClick?: (event: CanvasEvent<CanvasContainer>) => void;
+    onMouseEnter?: (event: CanvasEvent<CanvasContainer>) => void;
+    onMouseLeave?: (event: CanvasEvent<CanvasContainer>) => void;
+    onMouseDown?: (event: CanvasEvent<CanvasContainer>) => void;
+}
+interface TextProps extends CanvasInteractionProps, CanvasLayerProps, Omit<CanvasTextOptions, 'font' | 'fontSize' | 'lineHeightPx' | 'color'> {
+    children?: ReactNode;
+    font?: string;
+    color?: string;
+    style?: Partial<CanvasFlexStyle>;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface IconProps extends CanvasInteractionProps, CanvasLayerProps {
+    icon: ButtonIcon;
+    size?: number;
+    color?: string;
+    style?: Partial<CanvasFlexStyle>;
+    backgroundColor?: string;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    onClick?: (event: CanvasEvent<CanvasIcon>) => void;
+    onMouseEnter?: (event: CanvasEvent<CanvasIcon>) => void;
+    onMouseLeave?: (event: CanvasEvent<CanvasIcon>) => void;
+    onMouseDown?: (event: CanvasEvent<CanvasIcon>) => void;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface ButtonProps extends CanvasInteractionProps, CanvasLayerProps {
+    children: string;
+    variant?: 'primary' | 'secondary' | 'danger';
+    view?: ButtonView;
+    size?: ButtonSize;
+    leftIcon?: ButtonIcon;
+    rightIcon?: ButtonIcon;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent<CanvasButton>) => void;
+    style?: Partial<CanvasFlexStyle>;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface IconButtonProps extends CanvasInteractionProps, CanvasLayerProps {
+    icon: ButtonIcon;
+    size?: number | 'auto';
+    variant?: 'primary' | 'secondary' | 'danger';
+    view?: ButtonView;
+    buttonSize?: ButtonSize;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent<CanvasIconButton>) => void;
+    style?: Partial<CanvasFlexStyle>;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface EmbedIconButtonProps extends CanvasInteractionProps, CanvasLayerProps {
+    icon: ButtonIcon;
+    size?: number | 'auto';
+    variant?: 'primary' | 'secondary' | 'danger';
+    view?: ButtonView;
+    buttonSize?: EmbedIconButtonSize;
+    overrideSquareSize?: number;
+    overrideIconSize?: number;
+    iconColor?: string;
+    iconColorHovered?: string;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent<CanvasEmbedIconButton>) => void;
+    style?: Partial<CanvasFlexStyle>;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface CheckboxProps extends CanvasInteractionProps, CanvasLayerProps {
+    checked: boolean;
+    indeterminate?: boolean;
+    size?: number | 'auto';
+    theme?: GlideThemeForRender;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent<CanvasIconButton>) => void;
+    style?: Partial<CanvasFlexStyle>;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface RectProps extends CanvasInteractionProps, CanvasLayerProps {
+    color?: string;
+    borderColor?: string;
+    borderWidth?: number;
+    style?: Partial<CanvasFlexStyle>;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+interface BadgeProps extends CanvasInteractionProps, CanvasLayerProps {
+    text: string;
+    view?: BadgeView;
+    size?: BadgeSize;
+    transparent?: boolean;
+    clear?: boolean;
+    leftIcon?: ButtonIcon;
+    rightIcon?: ButtonIcon;
+    customColor?: string;
+    customBackgroundColor?: string;
+    style?: Partial<CanvasFlexStyle>;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+    pilled?: boolean;
+}
+interface SkeletonProps extends CanvasInteractionProps, CanvasLayerProps {
+    width?: number | string;
+    height?: number | string;
+    roundness?: number | string;
+    lighter?: boolean;
+    customGradientColor?: string;
+    animated?: boolean;
+    shimmerDuration?: number;
+    style?: Partial<CanvasFlexStyle>;
+    id?: string;
+}
+interface LinkProps extends CanvasInteractionProps, CanvasLayerProps, Omit<CanvasTextOptions, 'font' | 'fontSize' | 'lineHeightPx' | 'color'> {
+    children?: ReactNode;
+    href?: string;
+    target?: string;
+    view?: LinkView;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent<CanvasLink>) => void;
+    font?: string;
+    color?: string;
+    style?: Partial<CanvasFlexStyle>;
+    id?: string;
+    portalHoverEnabled?: boolean;
+    position?: 'absolute';
+    left?: PositionValue;
+    top?: PositionValue;
+    right?: PositionValue;
+    bottom?: PositionValue;
+    tooltip?: CanvasNodeTooltipConfig;
+}
+type CanvasComponentType = 'Container' | 'Text' | 'Icon' | 'Button' | 'IconButton' | 'EmbedIconButton' | 'Checkbox' | 'Rect' | 'Badge' | 'Skeleton' | 'Link';
+type CanvasComponentMarker = {
+    __canvasType: CanvasComponentType;
+};
+type CanvasComponent<P> = ((props: P) => ReactElement | null) & CanvasComponentMarker;
+export interface RootBridgeProps {
+    cellId: string;
+    renderContent: () => ReactElement;
+    nodeRegistry: React.MutableRefObject<Map<string, ReactElement>>;
+    onRegistryChange?: () => void;
+}
+export declare const RootBridge: React.MemoExoticComponent<({ cellId, renderContent, nodeRegistry, onRegistryChange, }: RootBridgeProps) => null>;
+export declare const Canvas: {
+    Container: CanvasComponent<ContainerProps>;
+    Text: CanvasComponent<TextProps>;
+    Icon: CanvasComponent<IconProps>;
+    Button: CanvasComponent<ButtonProps>;
+    IconButton: CanvasComponent<IconButtonProps>;
+    EmbedIconButton: CanvasComponent<EmbedIconButtonProps>;
+    Checkbox: CanvasComponent<CheckboxProps>;
+    Rect: CanvasComponent<RectProps>;
+    Badge: CanvasComponent<BadgeProps>;
+    Skeleton: CanvasComponent<SkeletonProps>;
+    Link: CanvasComponent<LinkProps>;
+    icon: typeof normalizeIcon;
+};
+export declare function buildCanvasTree({ element, idPrefix, theme, }: {
+    element: ReactElement;
+    idPrefix?: string;
+    theme: GlideThemeForRender;
+}): CanvasNode;
+export type { SkeletonProps as CanvasSkeletonProps, BadgeProps as CanvasBadgeProps, ButtonProps as CanvasButtonProps, ContainerProps as CanvasContainerProps, EmbedIconButtonProps as CanvasEmbedIconButtonProps, IconButtonProps as CanvasIconButtonProps, IconProps as CanvasIconProps, RectProps as CanvasRectProps, TextProps as CanvasTextProps, LinkProps as CanvasLinkProps, };

package/components/TableGlide/lib/canvas/core/CanvasAbsoluteContainer.d.ts

@@ -0,0 +1,9 @@
+import { DrawBatcher } from './DrawBatcher';
+import { CanvasContainer } from './CanvasContainer';
+
+export declare class CanvasAbsoluteContainer extends CanvasContainer {
+    performLayout(ctx: CanvasRenderingContext2D): void;
+    private layoutChildren;
+    private expandToFitBounds;
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/core/CanvasContainer.d.ts

@@ -0,0 +1,39 @@
+import { DrawBatcher } from './DrawBatcher';
+import { CanvasNode } from './CanvasNode';
+import { ICanvasContainer } from './CanvasContainer.type';
+import { PaddingBox, FlexBoxOptions } from '../miniflex';
+
+export * from './CanvasContainer.type';
+export declare const resolvePaddingBox: (padding: FlexBoxOptions['padding'] | undefined) => PaddingBox;
+export declare class CanvasContainer extends CanvasNode implements ICanvasContainer {
+    private flexOptionsValue;
+    cachedPadding: PaddingBox;
+    cachedIsRow: boolean;
+    cachedGap: number;
+    private optionsCacheValid;
+    private readonly positionResolver;
+    private readonly flexTreeBuilder;
+    private readonly layoutReconciler;
+    constructor(id: string, flexOptions?: FlexBoxOptions, backgroundColor?: string);
+    get flexOptions(): FlexBoxOptions;
+    set flexOptions(value: FlexBoxOptions);
+    setFlexOptions(options: Partial<FlexBoxOptions>): void;
+    private invalidateOptionsCache;
+    private ensureOptionsCache;
+    measure(ctx: CanvasRenderingContext2D): void;
+    private measureChildren;
+    private computeIntrinsicSize;
+    private applySizeConstraints;
+    private resolveStyleDimension;
+    private resolveParentContentSize;
+    performLayout(ctx: CanvasRenderingContext2D, preserveCurrentRect?: boolean): void;
+    private layoutPhase1Flexbox;
+    private layoutPhase2Absolute;
+    private layoutAbsoluteChildSubtree;
+    private clampWidthToParent;
+    separateChildrenByLayoutMode(): {
+        layoutChildren: CanvasNode[];
+        absoluteChildren: CanvasNode[];
+    };
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/core/CanvasContainer.type.d.ts

@@ -0,0 +1,18 @@
+import { DrawBatcher } from './DrawBatcher';
+import { ICanvasNode } from './CanvasNode.type';
+import { PaddingBox, FlexBoxOptions } from '../miniflex';
+
+export interface ICanvasContainer extends ICanvasNode {
+    cachedPadding: PaddingBox;
+    cachedIsRow: boolean;
+    cachedGap: number;
+    flexOptions: FlexBoxOptions;
+    setFlexOptions(options: Partial<FlexBoxOptions>): void;
+    measure(ctx: CanvasRenderingContext2D): void;
+    performLayout(ctx: CanvasRenderingContext2D, preserveCurrentRect?: boolean): void;
+    separateChildrenByLayoutMode(): {
+        layoutChildren: ICanvasNode[];
+        absoluteChildren: ICanvasNode[];
+    };
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/core/CanvasHoverController.d.ts

@@ -0,0 +1,31 @@
+import { CanvasPortalHoverDetail, CanvasPortalSource, TooltipContext } from '../utils/portalHoverEvents';
+import { CanvasEvent, CanvasNode, Rect } from './CanvasNode';
+
+export interface CanvasHoverControllerOptions {
+    onCursorChange?: (cursor: string) => void;
+    onPortalTargetChange?: (target: CanvasNode | null, baseEvent: CanvasEvent | null) => void;
+    portalHoverDispatch?: (detail: CanvasPortalHoverDetail, target?: EventTarget | null) => void;
+    getPortalEventTarget?: () => EventTarget | null;
+    portalSource?: CanvasPortalSource;
+    getTooltipContext?: () => TooltipContext | undefined;
+}
+export declare class CanvasHoverController {
+    private readonly options;
+    private hoveredNode;
+    private activePortalNode;
+    private currentCursor;
+    private bounds;
+    constructor(options?: CanvasHoverControllerOptions);
+    setAbsoluteBounds(bounds: Rect | null): void;
+    handlePointerMove(hits: CanvasNode[], baseEvent: CanvasEvent | null): void;
+    handlePointerLeave(): void;
+    handlePortalReset(): void;
+    computeCursor(relativeX: number, relativeY: number, rootNode: CanvasNode): string;
+    getCurrentCursor(): string;
+    private transitionHover;
+    private buildEvent;
+    private updateCursor;
+    private findPortalTarget;
+    private updatePortalHover;
+    private dispatchPortalHover;
+}