@daisforge/ui 1.10.3

package/components/TableGlide/lib/canvas/interaction/interactionManager.d.ts

@@ -0,0 +1,28 @@
+import { ResolvedCanvasInteractionConfig } from '../core/canvasInteraction';
+
+export interface InternalInteractionDecision {
+    suppressEarlyGridSelect: boolean;
+    suppressExternalCellClick: boolean;
+    suppressGridDefaultFor: {
+        pointerdown: boolean;
+        click: boolean;
+        contextmenu: boolean;
+    };
+    contextMenuMode: 'normal' | 'manual-keep-selection' | 'none';
+    editorRequest?: {
+        target: 'self';
+    };
+}
+export interface EffectiveInteractionOutcome {
+    suppressExternalCellClick: boolean;
+    suppressGridDefaultForClick: boolean;
+    editorRequest?: {
+        target: 'self';
+    };
+}
+export declare function resolveInteractionDecision(interaction: ResolvedCanvasInteractionConfig): InternalInteractionDecision;
+export declare function buildEffectiveInteractionOutcome({ decision, propagationStopped, suppressGridDefault, }: {
+    decision: InternalInteractionDecision;
+    propagationStopped: boolean;
+    suppressGridDefault: boolean;
+}): EffectiveInteractionOutcome;

package/components/TableGlide/lib/canvas/interaction/interactionSessionStore.d.ts

@@ -0,0 +1,63 @@
+import { InternalInteractionDecision } from './interactionManager';
+import { RelativePoint } from '../cells/renderer/types';
+import { CanvasClickDispatchResult } from '../cells/renderer/performCanvasClick';
+import { ResolvedCanvasInteractionConfig } from '../core/canvasInteraction';
+
+export type InteractionPhase = 'pointer-select' | 'cell-click' | 'renderer-click' | 'contextmenu-capture' | 'contextmenu-glide' | 'editor-activation';
+export type InteractionSessionSource = 'pointer' | 'click' | 'contextmenu' | 'keyboard' | 'synthetic';
+export interface ArmedEditorRequest {
+    target: 'self';
+    armedAt: number;
+    consumed?: boolean;
+}
+export interface InteractionSession {
+    id: number;
+    key: string;
+    cell: readonly [number, number];
+    relativePoint: RelativePoint;
+    interaction: ResolvedCanvasInteractionConfig;
+    decision: InternalInteractionDecision;
+    clickResult?: CanvasClickDispatchResult;
+    consumedPhases: Set<InteractionPhase>;
+    startedAt: number;
+    button?: number;
+    source: InteractionSessionSource;
+    editorRequest?: ArmedEditorRequest;
+}
+export interface BeginInteractionSessionArgs {
+    cell: readonly [number, number];
+    relativePoint: RelativePoint;
+    interaction: ResolvedCanvasInteractionConfig;
+    button?: number;
+    source: InteractionSessionSource;
+    startedAt?: number;
+}
+export interface FindInteractionSessionArgs {
+    cell: readonly [number, number];
+    relativePoint: RelativePoint;
+    button?: number;
+    maxAgeMs?: number;
+}
+export interface InteractionSessionStore {
+    beginOrGet: (args: BeginInteractionSessionArgs) => InteractionSession;
+    findMatching: (args: FindInteractionSessionArgs) => InteractionSession | undefined;
+    getCurrent: () => InteractionSession | undefined;
+    storeClickResult: (session: InteractionSession, result: CanvasClickDispatchResult) => void;
+    consumeClickResult: (args: FindInteractionSessionArgs) => CanvasClickDispatchResult | undefined;
+    consumePhase: (session: InteractionSession, phase: InteractionPhase) => boolean;
+    armEditorRequest: (session: InteractionSession, request: {
+        target: 'self';
+    }) => void;
+    consumeEditorRequest: (cell: readonly [number, number], maxAgeMs?: number) => {
+        target: 'self';
+    } | undefined;
+    isMatchingRecent: (phase: InteractionPhase, cell: readonly [number, number], maxAgeMs?: number) => boolean;
+    clearStale: (maxAgeMs?: number) => void;
+    clear: () => void;
+}
+export declare function buildInteractionSessionKey({ cell, relativePoint, button, }: {
+    cell: readonly [number, number];
+    relativePoint: RelativePoint;
+    button?: number;
+}): string;
+export declare function createInteractionSessionStore(): InteractionSessionStore;

package/components/TableGlide/lib/canvas/interaction/resolveCanvasCellInteractionTarget.d.ts

@@ -0,0 +1,35 @@
+import { ResolvedCanvasInteractionConfig } from '../core/canvasInteraction';
+import { RelativePoint } from '../cells/renderer/types';
+import { CanvasCell, CanvasRenderResult, RectBounds } from '../cells/types';
+import { DataEditorRef } from '@glideappsfinal/glide-data-grid';
+
+type MouseArgs = NonNullable<ReturnType<DataEditorRef['getMouseArgsForPosition']>>;
+type CellMouseArgs = Extract<MouseArgs, {
+    kind: 'cell';
+}>;
+export interface ResolvedCanvasCellInteractionTarget {
+    cell: [number, number];
+    mouseArgs?: CellMouseArgs;
+    glideCell: CanvasCell;
+    rect: RectBounds;
+    renderData: CanvasRenderResult | undefined;
+    relativePoint: RelativePoint;
+    interaction: ResolvedCanvasInteractionConfig;
+}
+export declare function resolveCanvasCellInteractionTargetFromRenderData({ cell, glideCell, rect, renderData, relativePoint, mouseArgs, }: {
+    cell: [number, number];
+    glideCell: CanvasCell;
+    rect: RectBounds;
+    renderData: CanvasRenderResult | undefined;
+    relativePoint: RelativePoint;
+    mouseArgs?: CellMouseArgs;
+}): ResolvedCanvasCellInteractionTarget | undefined;
+export declare function resolveCanvasCellInteractionTargetFromDomPoint({ dataEditor, getCellContent, clientX, clientY, nativeEvent, }: {
+    dataEditor: DataEditorRef | null;
+    getCellContent: (cell: [number, number]) => unknown;
+    clientX: number;
+    clientY: number;
+    nativeEvent?: MouseEvent | TouchEvent;
+}): ResolvedCanvasCellInteractionTarget | undefined;
+export declare const resolveCanvasCellInteractionTarget: typeof resolveCanvasCellInteractionTargetFromDomPoint;
+export {};

package/components/TableGlide/lib/canvas/miniflex/flexBoxLayout.d.ts

@@ -0,0 +1,9 @@
+import { FlexStyle, Position, Size } from './types';
+
+export interface FlexBoxItem extends FlexStyle {
+    children?: FlexBoxItem[];
+}
+export declare const flexBoxLayout: (parent: FlexBoxItem) => Record<string, {
+    position: Position;
+    size: Size;
+}>;

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

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

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

@@ -0,0 +1,3 @@
+export * from './flexBoxLayout';
+export * from './minimal-flexbox';
+export * from './types';

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

@@ -0,0 +1,8 @@
+import { F as x, l as a, R as l, m as s, r } from "../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  x as FlexBox,
+  a as FlexElement,
+  l as RootFlexBox,
+  s as flexBoxLayout,
+  r as resolvePaddingBox
+};

package/components/TableGlide/lib/canvas/miniflex/minimal-flexbox.d.ts

@@ -0,0 +1,56 @@
+import { Align, AlignContent, Direction, FlexBoxOptions, FlexStyle, Justify, Position, Size } from './types';
+
+export interface PaddingBox {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+declare abstract class FlexNode {
+    id?: string;
+    metadata?: unknown;
+    readonly size: Size;
+    readonly position: Position;
+    style: FlexStyle;
+    constructor(style?: Partial<FlexStyle>);
+    abstract build(): void;
+}
+export declare class FlexElement extends FlexNode {
+    build(): void;
+}
+export declare class FlexBox extends FlexNode {
+    readonly children: FlexNode[];
+    direction: Direction;
+    wrap: 'nowrap' | 'wrap' | 'wrap-reverse';
+    columnGap: number;
+    rowGap: number;
+    justifyContent: Justify;
+    alignItems: Align;
+    alignContent: AlignContent;
+    padding: PaddingBox;
+    constructor(width: number, height: number, opts?: FlexBoxOptions);
+    addChild(style: Partial<FlexStyle>): FlexElement;
+    addChild(box: FlexBox, style?: Partial<FlexStyle>): FlexBox;
+    private getContainerMetrics;
+    private buildFlexLines;
+    private measureLineCrossSizes;
+    private isDeferredCrossAxisPercentChild;
+    private resolveCrossAxisLayout;
+    private calculateAlignContent;
+    private distributeMainAxisSizes;
+    private calculateJustifySpacing;
+    private getFinalLineHeight;
+    private getCrossSize;
+    private positionChildren;
+    build(): void;
+}
+export declare function resolvePaddingBox(padding?: FlexBoxOptions['padding']): PaddingBox;
+export declare class RootFlexBox extends FlexBox {
+    constructor(width: number, height: number, opts?: FlexBoxOptions);
+    getLayout(): Record<string, {
+        position: Position;
+        size: Size;
+    }>;
+    private _collectLayout;
+}
+export {};

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

@@ -0,0 +1,40 @@
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface Position {
+    x: number;
+    y: number;
+}
+export type Direction = 'row' | 'row-reverse' | 'column' | 'column-reverse';
+export type Align = 'flex-start' | 'flex-end' | 'center' | 'stretch';
+export type CrossAxisSizing = 'auto' | 'deferred-percent-stretch';
+export type Justify = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly';
+export type AlignContent = 'flex-start' | 'flex-end' | 'center' | 'space-between' | 'space-around' | 'space-evenly' | 'stretch';
+export interface FlexStyle {
+    id?: string;
+    flexGrow: number;
+    flexShrink: number;
+    flexBasis: number;
+    alignSelf?: Align | 'auto';
+    width?: number;
+    height?: number;
+    crossAxisSizing?: CrossAxisSizing;
+    metadata?: unknown;
+}
+export interface FlexBoxOptions {
+    id?: string;
+    direction?: Direction;
+    wrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    columnGap?: number;
+    rowGap?: number;
+    justifyContent?: Justify;
+    alignItems?: Align;
+    alignContent?: AlignContent;
+    padding?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    } | number;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasBadge.d.ts

@@ -0,0 +1,35 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+import { ButtonIcon } from '../cells/buttons';
+import { Theme } from '../../../theming/types';
+
+export type BadgeView = 'default' | 'accent' | 'positive' | 'warning' | 'negative' | 'dark' | 'light';
+export type BadgeSize = 'xs' | 's' | 'm' | 'l';
+export interface CanvasBadgeOptions {
+    view?: BadgeView;
+    size?: BadgeSize;
+    transparent?: boolean;
+    clear?: boolean;
+    leftIcon?: ButtonIcon;
+    rightIcon?: ButtonIcon;
+    pilled?: boolean;
+    theme?: Theme;
+    customColor?: string;
+    customBackgroundColor?: string;
+}
+export declare class CanvasBadge extends CanvasLeaf {
+    text: string;
+    view: BadgeView;
+    size: BadgeSize;
+    transparent: boolean;
+    clear: boolean;
+    pilled: boolean;
+    leftIcon?: ButtonIcon;
+    rightIcon?: ButtonIcon;
+    private viewColors;
+    customColor?: string;
+    customBackgroundColor?: string;
+    constructor(id: string, text: string, options?: CanvasBadgeOptions);
+    measure(ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasButton.d.ts

@@ -0,0 +1,35 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasEvent, CanvasFlexStyle } from '../core/CanvasNode';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+import { ButtonIcon, ButtonSize, ButtonView } from '../cells/buttons';
+import { Theme } from '../../../theming/types';
+
+export interface CanvasButtonOptions {
+    variant?: 'primary' | 'secondary' | 'danger';
+    view?: ButtonView;
+    size?: ButtonSize;
+    leftIcon?: ButtonIcon;
+    rightIcon?: ButtonIcon;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent) => void;
+    theme?: Theme;
+}
+export declare class CanvasButton extends CanvasLeaf {
+    text: string;
+    variant: 'primary' | 'secondary' | 'danger';
+    view: ButtonView;
+    size: ButtonSize;
+    leftIcon?: ButtonIcon;
+    rightIcon?: ButtonIcon;
+    disabled: boolean;
+    isHovered: boolean;
+    private useNewApi;
+    private viewColors;
+    constructor(id: string, text: string, options?: CanvasButtonOptions);
+    set style(value: CanvasFlexStyle);
+    get style(): CanvasFlexStyle;
+    measure(ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasCheckbox.d.ts

@@ -0,0 +1,39 @@
+import { GlideThemeForRender } from '../../../theming/types';
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasEvent, CanvasFlexStyle } from '../core/CanvasNode';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+import { ButtonIcon } from '../cells/iconSprites';
+import { ButtonSize, ButtonView } from '../cells/buttons';
+
+export declare const CHECKBOX_ICONS: {
+    indeterminateIcon: string;
+    checkedIcon: string;
+};
+export declare const CHECKBOX_ICONS_ARR: string[];
+export interface CanvasCheckboxOptions {
+    size?: number | 'auto';
+    theme?: GlideThemeForRender;
+    view?: ButtonView;
+    buttonSize?: ButtonSize;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent) => void;
+}
+export declare class CanvasCheckbox extends CanvasLeaf {
+    icon: ButtonIcon;
+    size: number | 'auto';
+    checked: boolean;
+    indeterminate: boolean;
+    view: ButtonView;
+    buttonSize: ButtonSize;
+    disabled: boolean;
+    isHovered: boolean;
+    useNewApi: boolean;
+    theme: GlideThemeForRender | undefined;
+    constructor(id: string, icon: ButtonIcon, checked?: boolean, indeterminate?: boolean, options?: CanvasCheckboxOptions);
+    set style(value: CanvasFlexStyle);
+    get style(): CanvasFlexStyle;
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasChevron.d.ts

@@ -0,0 +1,14 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+
+export interface CanvasChevronOptions {
+    rotation?: number;
+    color?: string;
+}
+export declare class CanvasChevron extends CanvasLeaf {
+    rotation: number;
+    color: string;
+    constructor(id: string, options?: CanvasChevronOptions);
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasEmbedIconButton.d.ts

@@ -0,0 +1,41 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasEvent, CanvasFlexStyle } from '../core/CanvasNode';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+import { ButtonIcon } from '../cells/iconSprites';
+import { ButtonView, EmbedIconButtonSize } from '../cells/buttons';
+
+export interface CanvasEmbedIconButtonOptions {
+    size?: number | 'auto';
+    variant?: 'primary' | 'secondary' | 'danger';
+    view?: ButtonView;
+    buttonSize?: EmbedIconButtonSize;
+    overrideSquareSize?: number;
+    overrideIconSize?: number;
+    iconColor?: string;
+    iconColorHovered?: string;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent) => void;
+}
+export declare class CanvasEmbedIconButton extends CanvasLeaf {
+    icon: ButtonIcon;
+    size: number | 'auto';
+    variant: 'primary' | 'secondary' | 'danger';
+    view: ButtonView;
+    buttonSize: EmbedIconButtonSize;
+    disabled: boolean;
+    overrideSquareSize?: number;
+    overrideIconSize?: number;
+    iconColor?: string;
+    iconColorHovered?: string;
+    isHovered: boolean;
+    private useNewApi;
+    private getDisabled;
+    constructor(id: string, icon: ButtonIcon, options?: CanvasEmbedIconButtonOptions);
+    set style(value: CanvasFlexStyle);
+    get style(): CanvasFlexStyle;
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    protected containsHitPoint(x: number, y: number): boolean;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasIcon.d.ts

@@ -0,0 +1,16 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+import { ButtonIcon } from '../cells/iconSprites';
+
+export interface CanvasIconOptions {
+    size?: number;
+    color?: string;
+}
+export declare class CanvasIcon extends CanvasLeaf {
+    icon: ButtonIcon;
+    size: number;
+    color?: string;
+    constructor(id: string, icon: ButtonIcon, options?: CanvasIconOptions);
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasIconButton.d.ts

@@ -0,0 +1,32 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasEvent, CanvasFlexStyle } from '../core/CanvasNode';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+import { ButtonIcon } from '../cells/iconSprites';
+import { ButtonSize, ButtonView } from '../cells/buttons';
+
+export interface CanvasIconButtonOptions {
+    size?: number | 'auto';
+    variant?: 'primary' | 'secondary' | 'danger';
+    view?: ButtonView;
+    buttonSize?: ButtonSize;
+    disabled?: boolean;
+    onClick?: (event: CanvasEvent) => void;
+}
+export declare class CanvasIconButton extends CanvasLeaf {
+    icon: ButtonIcon;
+    size: number | 'auto';
+    variant: 'primary' | 'secondary' | 'danger';
+    view: ButtonView;
+    buttonSize: ButtonSize;
+    disabled: boolean;
+    isHovered: boolean;
+    private useNewApi;
+    constructor(id: string, icon: ButtonIcon, options?: CanvasIconButtonOptions);
+    set style(value: CanvasFlexStyle);
+    get style(): CanvasFlexStyle;
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    protected containsHitPoint(x: number, y: number): boolean;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasLink.d.ts

@@ -0,0 +1,43 @@
+import { Link } from '../../../../Link';
+import { CanvasText, CanvasTextOptions } from './CanvasText';
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasEvent, CanvasFlexStyle } from '../core/CanvasNode';
+import { Theme } from '../../../theming/types';
+import { ComponentProps } from 'react';
+
+type LinkAllProps = ComponentProps<typeof Link>;
+export type LinkView = Extract<LinkAllProps['view'], string>;
+export interface CanvasLinkOptions extends CanvasTextOptions {
+    href?: string;
+    target?: string;
+    rel?: string;
+    view?: LinkView;
+    disabled?: boolean;
+    theme?: Theme;
+}
+export declare class CanvasLink extends CanvasText {
+    href: string | undefined;
+    target: string | undefined;
+    rel: string | undefined;
+    view: LinkView;
+    disabled: boolean;
+    isHovered: boolean;
+    private isActive;
+    private customClickHandler;
+    private hasCustomColor;
+    private viewColors;
+    constructor(id: string, text: string, options?: CanvasLinkOptions);
+    set style(value: CanvasFlexStyle);
+    get style(): CanvasFlexStyle;
+    setOnClick(handler: ((event: CanvasEvent<CanvasLink>) => void) | undefined): void;
+    private resolveColor;
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    private paintUnderline;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onMouseDown(): void;
+    onMouseUp(): void;
+    onClick(event: CanvasEvent): void;
+    private navigate;
+}
+export {};

package/components/TableGlide/lib/canvas/primitives/CanvasRect.d.ts

@@ -0,0 +1,16 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+
+export interface CanvasRectOptions {
+    color?: string;
+    borderColor?: string;
+    borderWidth?: number;
+}
+export declare class CanvasRect extends CanvasLeaf {
+    color: string;
+    borderColor: string;
+    borderWidth: number;
+    constructor(id: string, color?: string);
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+}

package/components/TableGlide/lib/canvas/primitives/CanvasSkeleton.d.ts

@@ -0,0 +1,39 @@
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasLeaf } from '../core/CanvasLeaf';
+
+export interface CanvasSkeletonGradientStop {
+    offset: number;
+    color: string;
+}
+export interface CanvasSkeletonOptions {
+    roundness?: Roundness | string;
+    customGradientColor?: string;
+    lighter?: boolean;
+    animated?: boolean;
+    shimmerDuration?: number;
+}
+declare const ROUNDNESS_MAP: {
+    readonly 250: 15.625;
+    readonly 32: 2;
+    readonly 28: 1.75;
+    readonly 24: 1.5;
+    readonly 20: 1.25;
+    readonly 18: 1.125;
+    readonly 16: 1;
+    readonly 14: 0.875;
+    readonly 12: 0.75;
+    readonly 8: 0.5;
+    readonly 0: 0;
+};
+export type Roundness = keyof typeof ROUNDNESS_MAP;
+export declare class CanvasSkeleton extends CanvasLeaf {
+    private borderRadius;
+    private _gradientStops;
+    private _gradientAngle;
+    private animated;
+    private shimmerDuration;
+    constructor(id: string, options?: CanvasSkeletonOptions);
+    measure(_ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, _ctx: CanvasRenderingContext2D): void;
+}
+export {};

package/components/TableGlide/lib/canvas/primitives/CanvasText.d.ts

@@ -0,0 +1,58 @@
+import { CanvasNodeTooltipConfig, CanvasNodeTooltipProps } from '../utils/portalHoverEvents';
+import { CanvasTextOverflow } from '../utils/textOverflow';
+import { DrawBatcher } from '../core/DrawBatcher';
+import { CanvasNode } from '../core/CanvasNode';
+
+export type CanvasTextOverflowMode = 'visible' | 'hidden';
+export type CanvasTextAutoTooltip = boolean | (CanvasNodeTooltipProps & {
+    enabled?: boolean;
+    text?: string | ((fullText: string) => string | null);
+    mouseEnterDelay?: number;
+    mouseLeaveDelay?: number;
+});
+export interface CanvasTextOptions {
+    font?: string;
+    fontSize?: number;
+    lineHeightPx?: number;
+    color?: string;
+    wordWrap?: boolean;
+    lineHeight?: number;
+    overflow?: CanvasTextOverflowMode;
+    textOverflow?: CanvasTextOverflow;
+    ellipsis?: string;
+    maxLines?: number;
+    autoTooltip?: CanvasTextAutoTooltip;
+}
+export declare class CanvasText extends CanvasNode {
+    text: string;
+    font: string;
+    color: string;
+    fontSize: number | undefined;
+    lineHeightPx: number | undefined;
+    wordWrap: boolean;
+    lineHeight: number;
+    overflow: CanvasTextOverflowMode;
+    textOverflow: CanvasTextOverflow;
+    ellipsis: string;
+    maxLines: number | undefined;
+    autoTooltip: CanvasTextAutoTooltip | undefined;
+    private lastMeasureKey;
+    private cachedLines;
+    private cachedLinesKey;
+    private lastPaintedTextWidth;
+    constructor(id: string, text: string, options?: CanvasTextOptions);
+    measure(ctx: CanvasRenderingContext2D): void;
+    private measureWordWrap;
+    private measureSingleLineClamp;
+    private measureSingleLine;
+    protected getLastPaintedTextWidth(): number;
+    getTooltip(): CanvasNodeTooltipConfig | undefined;
+    private computeIsTruncated;
+    private getResolvedMaxLines;
+    private isSingleLineClampEnabled;
+    private isMultilineClampEnabled;
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    private paintMultiline;
+    private paintSingleLine;
+}
+export declare function invalidateTextCache(): void;

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.CanvasBadge=a.CanvasBadge;exports.CanvasButton=a.CanvasButton;exports.CanvasChevron=a.CanvasChevron;exports.CanvasEmbedIconButton=a.CanvasEmbedIconButton;exports.CanvasIcon=a.CanvasIcon;exports.CanvasIconButton=a.CanvasIconButton;exports.CanvasLink=a.CanvasLink;exports.CanvasRect=a.CanvasRect;exports.CanvasSkeleton=a.CanvasSkeleton;exports.CanvasText=a.CanvasText;

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

@@ -0,0 +1,20 @@
+export type { BadgeSize, BadgeView, CanvasBadgeOptions } from './CanvasBadge';
+export { CanvasBadge } from './CanvasBadge';
+export type { CanvasButtonOptions } from './CanvasButton';
+export { CanvasButton } from './CanvasButton';
+export type { CanvasChevronOptions } from './CanvasChevron';
+export { CanvasChevron } from './CanvasChevron';
+export type { CanvasEmbedIconButtonOptions } from './CanvasEmbedIconButton';
+export { CanvasEmbedIconButton } from './CanvasEmbedIconButton';
+export type { CanvasIconOptions } from './CanvasIcon';
+export { CanvasIcon } from './CanvasIcon';
+export type { CanvasIconButtonOptions } from './CanvasIconButton';
+export { CanvasIconButton } from './CanvasIconButton';
+export { type CanvasRectOptions } from './CanvasRect';
+export { CanvasRect } from './CanvasRect';
+export type { CanvasTextAutoTooltip, CanvasTextOptions } from './CanvasText';
+export { CanvasText } from './CanvasText';
+export type { CanvasSkeletonOptions } from './CanvasSkeleton';
+export { CanvasSkeleton } from './CanvasSkeleton';
+export { type CanvasLinkOptions, type LinkView } from './CanvasLink';
+export { CanvasLink } from './CanvasLink';