@daisforge/ui 1.10.3

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

@@ -0,0 +1,5 @@
+import { CanvasNode } from './CanvasNode';
+
+export declare abstract class CanvasLeaf extends CanvasNode {
+    addChild(): void;
+}

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

@@ -0,0 +1,72 @@
+import { DrawBatcher } from './DrawBatcher';
+import { ResolvedCanvasInteractionConfig } from './canvasInteraction';
+import { CanvasEvent, CanvasFlexStyle, ICanvasNode, PositionType, PositionValue, Rect } from './CanvasNode.type';
+import { CanvasNodeTooltipConfig } from '../utils/portalHoverEvents';
+
+export * from './CanvasNode.type';
+export declare abstract class CanvasNode implements ICanvasNode {
+    debugColor: string;
+    id: string;
+    parent: CanvasNode | null;
+    children: CanvasNode[];
+    rect: Rect;
+    zIndex: number;
+    protected _intrinsicWidth: number;
+    protected _intrinsicHeight: number;
+    protected _layoutDirty: boolean;
+    protected _measureDirty: boolean;
+    private _style;
+    private _position;
+    private _left;
+    private _top;
+    private _right;
+    private _bottom;
+    get style(): CanvasFlexStyle;
+    set style(value: CanvasFlexStyle);
+    get position(): PositionType;
+    set position(value: PositionType);
+    get left(): PositionValue | undefined;
+    set left(value: PositionValue | undefined);
+    get top(): PositionValue | undefined;
+    set top(value: PositionValue | undefined);
+    get right(): PositionValue | undefined;
+    set right(value: PositionValue | undefined);
+    get bottom(): PositionValue | undefined;
+    set bottom(value: PositionValue | undefined);
+    isAbsolute(): boolean;
+    isPositioningContext(): boolean;
+    static DEBUG: boolean;
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: number;
+    portalHoverEnabled: boolean;
+    tooltip?: CanvasNodeTooltipConfig;
+    interaction?: ResolvedCanvasInteractionConfig;
+    constructor(id: string);
+    markLayoutDirty(): void;
+    markMeasureDirty(): void;
+    isLayoutDirty(): boolean;
+    isMeasureDirty(): boolean;
+    protected clearLayoutDirty(): void;
+    protected clearMeasureDirty(): void;
+    addChild(child: CanvasNode): void;
+    addChildStart(child: CanvasNode): void;
+    removeChild(child: CanvasNode): void;
+    getTooltip(): CanvasNodeTooltipConfig | undefined;
+    abstract measure(ctx: CanvasRenderingContext2D): void;
+    paint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    abstract onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    hitTest(x: number, y: number): CanvasNode[];
+    requestLayout(): void;
+    requestPaint(): void;
+    onClick(_event: CanvasEvent<CanvasNode>): void;
+    onMouseDown(_event: CanvasEvent<CanvasNode>): void;
+    onMouseUp(_event: CanvasEvent<CanvasNode>): void;
+    onMouseEnter(_event: CanvasEvent<CanvasNode>): void;
+    onMouseLeave(_event: CanvasEvent<CanvasNode>): void;
+    onMouseMove(_event: CanvasEvent<CanvasNode>): void;
+    onDoubleClick(_event: CanvasEvent<CanvasNode>): void;
+    private attachChild;
+    private collectHitCandidates;
+    protected containsHitPoint(x: number, y: number): boolean;
+}

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

@@ -0,0 +1,73 @@
+import { DrawBatcher } from './DrawBatcher';
+import { FlexStyle } from '../miniflex/types';
+
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export type DimensionValue = number | '100%';
+export type PositionType = 'static' | 'relative' | 'absolute';
+export type PositionValue = number | string;
+export type CanvasFlexStyle = Omit<Partial<FlexStyle>, 'width' | 'height' | 'crossAxisSizing'> & {
+    width?: DimensionValue;
+    height?: DimensionValue;
+    cursor?: string;
+    marginRight?: number;
+};
+export interface CanvasEvent<T = any> {
+    type: string;
+    x: number;
+    y: number;
+    originalEvent: MouseEvent | any;
+    target?: any;
+    currentTarget?: T;
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    cellBounds?: Rect | null;
+}
+export interface ICanvasNode {
+    id: string;
+    debugColor: string;
+    parent: ICanvasNode | null;
+    children: ICanvasNode[];
+    rect: Rect;
+    zIndex: number;
+    backgroundColor: string;
+    borderColor: string;
+    borderWidth: number;
+    portalHoverEnabled: boolean;
+    tooltip?: string | {
+        text: string;
+        [key: string]: unknown;
+    };
+    style: CanvasFlexStyle;
+    position: PositionType;
+    left: PositionValue | undefined;
+    top: PositionValue | undefined;
+    right: PositionValue | undefined;
+    bottom: PositionValue | undefined;
+    isAbsolute(): boolean;
+    isPositioningContext(): boolean;
+    isLayoutDirty(): boolean;
+    isMeasureDirty(): boolean;
+    markLayoutDirty(): void;
+    markMeasureDirty(): void;
+    addChild(child: ICanvasNode): void;
+    addChildStart(child: ICanvasNode): void;
+    removeChild(child: ICanvasNode): void;
+    requestLayout(): void;
+    requestPaint(): void;
+    measure(ctx: CanvasRenderingContext2D): void;
+    paint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    onPaint(batcher: DrawBatcher, ctx: CanvasRenderingContext2D): void;
+    hitTest(x: number, y: number): ICanvasNode[];
+    onClick(event: CanvasEvent<ICanvasNode>): void;
+    onMouseDown(event: CanvasEvent<ICanvasNode>): void;
+    onMouseUp(event: CanvasEvent<ICanvasNode>): void;
+    onMouseEnter(event: CanvasEvent<ICanvasNode>): void;
+    onMouseLeave(event: CanvasEvent<ICanvasNode>): void;
+    onMouseMove(event: CanvasEvent<ICanvasNode>): void;
+    onDoubleClick(event: CanvasEvent<ICanvasNode>): void;
+}

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

@@ -0,0 +1,12 @@
+import { CanvasNode } from './CanvasNode';
+
+export type RegistryListener = (id: string) => void;
+export declare class CanvasRegistry {
+    private nodes;
+    private listeners;
+    register(id: string, node: CanvasNode): void;
+    unregister(id: string): void;
+    get(id: string): CanvasNode | undefined;
+    subscribe(listener: RegistryListener): () => void;
+    private notify;
+}

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

@@ -0,0 +1,26 @@
+import { CanvasEvent, CanvasNode } from './CanvasNode';
+
+export declare class CanvasRoot {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    rootNode: CanvasNode;
+    private hoverController;
+    private eventHandlers;
+    private batcher;
+    onCursorChange?: (cursor: string) => void;
+    onPortalHoverTargetChange?: (node: CanvasNode | null, event: CanvasEvent | null) => void;
+    constructor(canvas: HTMLCanvasElement, rootNode: CanvasNode);
+    private setupEvents;
+    destroy(): void;
+    private dispatchPointerEvent;
+    private getEventCoords;
+    private bubbleEvent;
+    private dispatchMouseMove;
+    private dispatchToNodes;
+    private invokePointerHandler;
+    render(): void;
+    private clearCanvas;
+    private applyResolutionScale;
+    private updateRootRect;
+    private layoutRoot;
+}

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

@@ -0,0 +1,126 @@
+export type TextBaseline = 'top' | 'middle' | 'bottom' | 'alphabetic' | 'hanging' | 'ideographic';
+export type TextAlign = 'left' | 'right' | 'center' | 'start' | 'end';
+interface BaseCommand {
+    zIndex: number;
+    order: number;
+}
+interface FillRectCommand extends BaseCommand {
+    type: 'fillRect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fillStyle: string;
+}
+interface StrokeRectCommand extends BaseCommand {
+    type: 'strokeRect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    strokeStyle: string;
+    lineWidth: number;
+}
+interface FillTextCommand extends BaseCommand {
+    type: 'fillText';
+    text: string;
+    x: number;
+    y: number;
+    font: string;
+    fillStyle: string;
+    textBaseline: TextBaseline;
+    textAlign?: TextAlign;
+}
+interface FillTextClippedCommand extends BaseCommand {
+    type: 'fillTextClipped';
+    text: string;
+    x: number;
+    y: number;
+    font: string;
+    fillStyle: string;
+    textBaseline: TextBaseline;
+    textAlign?: TextAlign;
+    clipX: number;
+    clipY: number;
+    clipWidth: number;
+    clipHeight: number;
+}
+interface DrawImageCommand extends BaseCommand {
+    type: 'drawImage';
+    image: CanvasImageSource;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface RoundedRectCommand extends BaseCommand {
+    type: 'roundedRect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    fillStyle?: string;
+    strokeStyle?: string;
+    lineWidth?: number;
+}
+export interface GradientStop {
+    offset: number;
+    color: string;
+}
+interface LinearGradientRectCommand extends BaseCommand {
+    type: 'linearGradientRect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    gradientStops: GradientStop[];
+    angle: number;
+}
+export interface AnimationContext {
+    frameTime?: number;
+    requestAnimationFrame?: () => void;
+}
+interface CustomCommand extends BaseCommand {
+    type: 'custom';
+    fn: (ctx: CanvasRenderingContext2D) => void;
+}
+export type DrawCommand = FillRectCommand | StrokeRectCommand | FillTextCommand | FillTextClippedCommand | DrawImageCommand | RoundedRectCommand | CustomCommand | LinearGradientRectCommand;
+export declare class DrawBatcher {
+    private commands;
+    private orderCounter;
+    private currentZIndex;
+    private animationContext?;
+    setAnimationContext(context?: AnimationContext): this;
+    getAnimationContext(): AnimationContext | undefined;
+    setZIndex(zIndex: number): this;
+    getZIndex(): number;
+    pushZIndex(delta?: number): this;
+    popZIndex(delta?: number): this;
+    fillRect(x: number, y: number, width: number, height: number, fillStyle: string): this;
+    strokeRect(x: number, y: number, width: number, height: number, strokeStyle: string, lineWidth?: number): this;
+    fillText(text: string, x: number, y: number, font: string, fillStyle: string, textBaseline?: TextBaseline, textAlign?: TextAlign): this;
+    fillTextClipped(text: string, x: number, y: number, font: string, fillStyle: string, clipRect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, textBaseline?: TextBaseline, textAlign?: TextAlign): this;
+    drawImage(image: CanvasImageSource, x: number, y: number, width: number, height: number): this;
+    roundedRect(x: number, y: number, width: number, height: number, radius: number, options?: {
+        fillStyle?: string;
+        strokeStyle?: string;
+        lineWidth?: number;
+    }): this;
+    linearGradientRect(x: number, y: number, width: number, height: number, radius: number, gradientStops: GradientStop[], angle?: number): this;
+    custom(fn: (ctx: CanvasRenderingContext2D) => void): this;
+    clear(): this;
+    get commandCount(): number;
+    flush(ctx: CanvasRenderingContext2D): void;
+    private executeLinearGradientRect;
+    private executeFillTextClipped;
+    private executeRoundedRect;
+}
+export declare const defaultBatcher: DrawBatcher;
+export {};

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

@@ -0,0 +1,10 @@
+export interface CanvasInteractionOptions {
+    selection?: 'normal' | 'keep';
+    cellClick?: 'normal' | 'stop';
+    editor?: 'normal' | 'never' | 'open-on-click';
+    contextMenu?: 'normal' | 'keep-selection' | 'none';
+}
+export type CanvasInteractionConfig = CanvasInteractionOptions;
+export type ResolvedCanvasInteractionConfig = Required<CanvasInteractionOptions>;
+export declare function normalizeCanvasInteraction(config: CanvasInteractionConfig | undefined): ResolvedCanvasInteractionConfig | undefined;
+export declare function createNormalCanvasInteraction(): ResolvedCanvasInteractionConfig;

package/components/TableGlide/lib/canvas/core/helpers/FlexTreeBuilder.d.ts

@@ -0,0 +1,12 @@
+import { ICanvasNode } from '../CanvasNode.type';
+import { FlexBox } from '../../miniflex';
+
+export declare class FlexTreeBuilder {
+    private defaultFlexStyle;
+    build(canvasNode: ICanvasNode, flexBox: FlexBox, flowChildren?: ICanvasNode[]): void;
+    private extractChildFlexProperties;
+    private handlePercentageDimensions;
+    private isContainer;
+    private addContainerChild;
+    private addLeafChild;
+}

package/components/TableGlide/lib/canvas/core/helpers/LayoutReconciler.d.ts

@@ -0,0 +1,20 @@
+import { PositionResolver } from './PositionResolver';
+import { ICanvasNode, Rect } from '../CanvasNode.type';
+import { FlexBox, FlexElement } from '../../miniflex';
+
+export declare class LayoutReconciler {
+    private positionResolver;
+    constructor(positionResolver: PositionResolver);
+    reconcile(ctx: CanvasRenderingContext2D, canvasNode: ICanvasNode, flexNode: FlexElement | FlexBox, flowChildren?: ICanvasNode[], rootRect?: Rect, preserveCurrentRect?: boolean): boolean;
+    private updateNodePosition;
+    private reconcileChildLayouts;
+    private updateContainerFromContent;
+    private syncFlexNodeSizeFromRect;
+    private syncAutoMainAxisFlexBasis;
+    private remeasureAndUpdateLeaf;
+    private positionNestedAbsoluteChildren;
+    private layoutAbsoluteChildSubtree;
+    private isContainer;
+    private getContainerCachedIsRow;
+    private getContainerCachedPadding;
+}

package/components/TableGlide/lib/canvas/core/helpers/PositionResolver.d.ts

@@ -0,0 +1,9 @@
+import { ICanvasNode, PositionValue, Rect } from '../CanvasNode.type';
+import { PaddingBox } from '../../miniflex';
+
+export declare class PositionResolver {
+    static resolvePositionValue(value: PositionValue | undefined, parentSize: number): number | undefined;
+    private static applyAxisPositioning;
+    applyAbsolutePositioning(child: ICanvasNode, referenceRect: Rect): void;
+    positionAbsoluteChildren(containerRect: Rect, containerPadding: PaddingBox, absoluteChildren: ICanvasNode[], measureFn: (child: ICanvasNode) => void, layoutFn?: (child: ICanvasNode) => void): void;
+}

package/components/TableGlide/lib/canvas/core/helpers/SizeAccumulator.d.ts

@@ -0,0 +1,20 @@
+import { Rect } from '../CanvasNode';
+
+export declare class SizeAccumulator {
+    private width;
+    private height;
+    private maxCrossSize;
+    private childCount;
+    private isRow;
+    reset(): void;
+    accumulate(childRect: Rect, isRow: boolean): void;
+    addGap(gap: number, isRow: boolean): void;
+    getSize(): {
+        width: number;
+        height: number;
+    };
+    static computeIntrinsicSize(children: Rect[], isRow: boolean, gap: number): {
+        width: number;
+        height: number;
+    };
+}

package/components/TableGlide/lib/canvas/core/helpers/index.cjs

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

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

@@ -0,0 +1,4 @@
+export { FlexTreeBuilder } from './FlexTreeBuilder';
+export { LayoutReconciler } from './LayoutReconciler';
+export { PositionResolver } from './PositionResolver';
+export { SizeAccumulator } from './SizeAccumulator';

package/components/TableGlide/lib/canvas/core/helpers/index.mjs

@@ -0,0 +1,7 @@
+import { n as r, L as a, P as s, S as i } from "../../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  r as FlexTreeBuilder,
+  a as LayoutReconciler,
+  s as PositionResolver,
+  i as SizeAccumulator
+};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("../../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.CanvasAbsoluteContainer=a.CanvasAbsoluteContainer;exports.CanvasContainer=a.CanvasContainer;exports.CanvasHoverController=a.CanvasHoverController;exports.CanvasLeaf=a.CanvasLeaf;exports.CanvasNode=a.CanvasNode;exports.CanvasRegistry=a.CanvasRegistry;exports.CanvasRoot=a.CanvasRoot;exports.DrawBatcher=a.DrawBatcher;exports.createNormalCanvasInteraction=a.createNormalCanvasInteraction;exports.defaultBatcher=a.defaultBatcher;exports.normalizeCanvasInteraction=a.normalizeCanvasInteraction;exports.resolvePaddingBox=a.resolvePaddingBox$1;

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

@@ -0,0 +1,14 @@
+export { CanvasAbsoluteContainer } from './CanvasAbsoluteContainer';
+export { CanvasContainer, resolvePaddingBox } from './CanvasContainer';
+export type { CanvasHoverControllerOptions } from './CanvasHoverController';
+export { CanvasHoverController } from './CanvasHoverController';
+export { CanvasLeaf } from './CanvasLeaf';
+export type { CanvasInteractionConfig, CanvasInteractionOptions, ResolvedCanvasInteractionConfig, } from './canvasInteraction';
+export { createNormalCanvasInteraction, normalizeCanvasInteraction, } from './canvasInteraction';
+export type { CanvasEvent, CanvasFlexStyle, DimensionValue, Rect, } from './CanvasNode';
+export { CanvasNode } from './CanvasNode';
+export type { RegistryListener } from './CanvasRegistry';
+export { CanvasRegistry } from './CanvasRegistry';
+export { CanvasRoot } from './CanvasRoot';
+export type { DrawCommand, TextAlign, TextBaseline } from './DrawBatcher';
+export { defaultBatcher, DrawBatcher } from './DrawBatcher';

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

@@ -0,0 +1,15 @@
+import { o as n, p as e, q as o, t as r, u as t, v, w as C, x as i, y as l, z as c, A as d, B } from "../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  n as CanvasAbsoluteContainer,
+  e as CanvasContainer,
+  o as CanvasHoverController,
+  r as CanvasLeaf,
+  t as CanvasNode,
+  v as CanvasRegistry,
+  C as CanvasRoot,
+  i as DrawBatcher,
+  l as createNormalCanvasInteraction,
+  c as defaultBatcher,
+  d as normalizeCanvasInteraction,
+  B as resolvePaddingBox
+};

package/components/TableGlide/lib/canvas/hooks/fontUtils.d.ts

@@ -0,0 +1,11 @@
+export declare function waitForDocumentFonts(): Promise<void>;
+interface PollOptions {
+    testFont?: string;
+    testText?: string;
+    maxChecks?: number;
+    checkInterval?: number;
+    stableThreshold?: number;
+}
+export declare function waitForCanvasFonts(options?: PollOptions): Promise<void>;
+export declare function waitForFonts(options?: PollOptions): Promise<void>;
+export {};

package/components/TableGlide/lib/canvas/hooks/gridUpdateUtils.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+import { DataEditorRef } from '@glideappsfinal/glide-data-grid';
+
+interface GridUpdateParams {
+    dataEditorRef: RefObject<DataEditorRef>;
+    rowCount: number;
+    columnCount: number;
+    headerAndGroupHeaderRowsCount: number;
+}
+export declare function updateGridCells({ dataEditorRef, rowCount, columnCount, headerAndGroupHeaderRowsCount, }: GridUpdateParams): void;
+export declare function createRafUpdate(fn: () => void): () => void;
+export {};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.createRafUpdate=e.createRafUpdate;exports.updateGridCells=e.updateGridCells;exports.useCanvasRegistry=e.useCanvasRegistry;exports.useFontLoadRedraw=e.useFontLoadRedraw;exports.useIconLoadRedraw=e.useIconLoadRedraw;exports.waitForCanvasFonts=e.waitForCanvasFonts;exports.waitForDocumentFonts=e.waitForDocumentFonts;exports.waitForFonts=e.waitForFonts;

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

@@ -0,0 +1,5 @@
+export { waitForCanvasFonts, waitForDocumentFonts, waitForFonts, } from './fontUtils';
+export { createRafUpdate, updateGridCells } from './gridUpdateUtils';
+export { useCanvasRegistry } from './useCanvasRegistry';
+export { useFontLoadRedraw } from './useFontLoadRedraw';
+export { useIconLoadRedraw } from './useIconLoadRedraw';

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

@@ -0,0 +1,11 @@
+import { bo as o, bp as t, bq as e, br as r, bs as b, bt as n, bu as d, bv as F } from "../../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  o as createRafUpdate,
+  t as updateGridCells,
+  e as useCanvasRegistry,
+  r as useFontLoadRedraw,
+  b as useIconLoadRedraw,
+  n as waitForCanvasFonts,
+  d as waitForDocumentFonts,
+  F as waitForFonts
+};

package/components/TableGlide/lib/canvas/hooks/useCanvasRegistry.d.ts

@@ -0,0 +1,6 @@
+import { CanvasRegistry } from '../core/CanvasRegistry';
+
+export declare function useCanvasRegistry(): {
+    registry: CanvasRegistry;
+    getRegistry: () => CanvasRegistry;
+};

package/components/TableGlide/lib/canvas/hooks/useFontLoadRedraw.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+import { DataEditorRef } from '@glideappsfinal/glide-data-grid';
+
+interface UseFontLoadRedrawParams {
+    dataEditorRef: RefObject<DataEditorRef>;
+    rowCount: number;
+    columnCount: number;
+    headerAndGroupHeaderRowsCount: number;
+}
+export declare function useFontLoadRedraw({ dataEditorRef, rowCount, columnCount, headerAndGroupHeaderRowsCount, }: UseFontLoadRedrawParams): void;
+export {};

package/components/TableGlide/lib/canvas/hooks/useIconLoadRedraw.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+import { DataEditorRef } from '@glideappsfinal/glide-data-grid';
+
+interface UseIconLoadRedrawParams {
+    dataEditorRef: RefObject<DataEditorRef>;
+    rowCount: number;
+    columnCount: number;
+    headerAndGroupHeaderRowsCount: number;
+}
+export declare function useIconLoadRedraw({ dataEditorRef, rowCount, columnCount, headerAndGroupHeaderRowsCount, }: UseIconLoadRedrawParams): void;
+export {};

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

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("../../../../chunks/TableGlide-DBSIrlp_.cjs");exports.BUTTON_PADDING_Y=e.BUTTON_PADDING_Y;exports.CANVAS_CELL_KIND=e.CANVAS_CELL_KIND;exports.CANVAS_PORTAL_EVENT=e.CANVAS_PORTAL_EVENT;exports.Canvas=e.Canvas;exports.CanvasAbsoluteContainer=e.CanvasAbsoluteContainer;exports.CanvasBadge=e.CanvasBadge;exports.CanvasButton=e.CanvasButton;exports.CanvasChevron=e.CanvasChevron;exports.CanvasContainer=e.CanvasContainer;exports.CanvasEmbedIconButton=e.CanvasEmbedIconButton;exports.CanvasHoverController=e.CanvasHoverController;exports.CanvasIcon=e.CanvasIcon;exports.CanvasIconButton=e.CanvasIconButton;exports.CanvasLeaf=e.CanvasLeaf;exports.CanvasLink=e.CanvasLink;exports.CanvasNode=e.CanvasNode;exports.CanvasRect=e.CanvasRect;exports.CanvasRegistry=e.CanvasRegistry;exports.CanvasRoot=e.CanvasRoot;exports.CanvasText=e.CanvasText;exports.CellCanvasRoot=e.CellCanvasRoot;exports.DrawBatcher=e.DrawBatcher;exports.FlexBox=e.FlexBox;exports.FlexElement=e.FlexElement;exports.ICON_SIZE_ADJUSTMENT=e.ICON_SIZE_ADJUSTMENT;exports.RootBridge=e.RootBridge;exports.RootFlexBox=e.RootFlexBox;exports.SIZE_CONFIG=e.SIZE_CONFIG;exports.VIEW_COLORS=e.VIEW_COLORS;exports.buildCanvasTree=e.buildCanvasTree;exports.buildCellId=e.buildCellId;exports.canvasCellRenderer=e.canvasCellRenderer;exports.clearIconCache=e.clearIconCache;exports.createCanvasCell=e.createCanvasCell;exports.createCanvasCellRenderer=e.createCanvasCellRenderer;exports.createNormalCanvasInteraction=e.createNormalCanvasInteraction;exports.defaultBatcher=e.defaultBatcher;exports.dispatchCanvasPortalHover=e.dispatchCanvasPortalHover;exports.drawButton=e.drawButton;exports.drawButtonWithView=e.drawButtonWithView;exports.drawIcon=e.drawIcon$1;exports.drawIconButton=e.drawIconButton;exports.drawIconButtonWithView=e.drawIconButtonWithView;exports.flexBoxLayout=e.flexBoxLayout;exports.getCellIndices=e.getCellIndices;exports.getHoverState=e.getHoverState;exports.getIconCacheSize=e.getIconCacheSize;exports.getIconImageDirect=e.getIconImageDirect;exports.getIconSprite=e.getIconSprite;exports.getIconSpriteStats=e.getIconSpriteStats;exports.isCanvasCell=e.isCanvasCell;exports.isHoveringBounds=e.isHoveringBounds;exports.isPointInArea=e.isPointInArea;exports.isPortalHoverLocked=e.isPortalHoverLocked;exports.isReactIcon=e.isReactIcon;exports.lockPortalHover=e.lockPortalHover;exports.normalizeCanvasInteraction=e.normalizeCanvasInteraction;exports.normalizeHoverPoint=e.normalizeHoverPoint;exports.normalizeIcon=e.normalizeIcon;exports.onAnyIconLoad=e.onAnyIconLoad;exports.performCanvasClick=e.performCanvasClick;exports.performCanvasPointerDownIntent=e.performCanvasPointerDownIntent;exports.preloadIconSprites=e.preloadIconSprites;exports.reactIconToSvg=e.reactIconToSvg;exports.registerIconDefinitions=e.registerIconDefinitions;exports.resetIconSpriteCache=e.resetIconSpriteCache;exports.resolveClickPoint=e.resolveClickPoint;exports.resolveFlexPaddingBox=e.resolvePaddingBox;exports.resolvePaddingBox=e.resolvePaddingBox$1;exports.retrieveRenderData=e.retrieveRenderData;exports.storeRenderData=e.storeRenderData;exports.subscribeToCanvasPortalHover=e.subscribeToCanvasPortalHover;exports.subscribeToPortalHoverLock=e.subscribeToPortalHoverLock;exports.toRelativePoint=e.toRelativePoint;exports.updateHoverState=e.updateHoverState;exports.useCanvasRegistry=e.useCanvasRegistry;

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

@@ -0,0 +1,13 @@
+export type { CanvasEvent, CanvasFlexStyle, CanvasHoverControllerOptions, CanvasInteractionConfig, CanvasInteractionOptions, DimensionValue, DrawCommand, Rect, ResolvedCanvasInteractionConfig, RegistryListener, TextAlign, TextBaseline, } from './core';
+export { CanvasAbsoluteContainer, CanvasContainer, CanvasHoverController, CanvasLeaf, CanvasNode, CanvasRegistry, CanvasRoot, createNormalCanvasInteraction, defaultBatcher, DrawBatcher, normalizeCanvasInteraction, resolvePaddingBox, } from './core';
+export type { BadgeSize, BadgeView, CanvasBadgeOptions, CanvasButtonOptions, CanvasChevronOptions, CanvasIconButtonOptions, CanvasIconOptions, CanvasTextAutoTooltip, CanvasTextOptions, CanvasLinkOptions, LinkView, } from './primitives';
+export { CanvasBadge, CanvasButton, CanvasChevron, CanvasEmbedIconButton, CanvasIcon, CanvasIconButton, CanvasRect, CanvasText, CanvasLink, } from './primitives';
+export type { ButtonIcon, ButtonSize, ButtonView, CanvasCell, CanvasCellData, CanvasClickDispatchResult, CanvasCellRendererConfig, CanvasPointerIntentResult, CanvasRenderResult, CellIndices, HoverMeta, HoverState, IconDefinition, IconSpriteOptions, IconSpriteStats, Point, RectBounds, RenderClickHandler, SizeConfig, ViewColors, } from './cells';
+export { buildCellId, BUTTON_PADDING_Y, CANVAS_CELL_KIND, canvasCellRenderer, CellCanvasRoot, createCanvasCell, createCanvasCellRenderer, drawButton, drawButtonWithView, drawIcon, drawIconButton, drawIconButtonWithView, getCellIndices, getHoverState, getIconImageDirect, getIconSprite, getIconSpriteStats, ICON_SIZE_ADJUSTMENT, isCanvasCell, isHoveringBounds, isPointInArea, normalizeHoverPoint, onAnyIconLoad, performCanvasClick, performCanvasPointerDownIntent, preloadIconSprites, registerIconDefinitions, resetIconSpriteCache, resolveClickPoint, retrieveRenderData, SIZE_CONFIG, storeRenderData, toRelativePoint, updateHoverState, VIEW_COLORS, } from './cells';
+export type { CanvasPortalHoverDetail, CanvasPortalHoverListener, CanvasPortalSource, CanvasNodeTooltipConfig, CanvasNodeTooltipProps, } from './utils';
+export { CANVAS_PORTAL_EVENT, clearIconCache, dispatchCanvasPortalHover, getIconCacheSize, isPortalHoverLocked, isReactIcon, lockPortalHover, normalizeIcon, reactIconToSvg, subscribeToCanvasPortalHover, subscribeToPortalHoverLock, } from './utils';
+export type { Align, AlignContent, Direction, FlexBoxItem, FlexBoxOptions, FlexStyle, Justify, Position, Size, PaddingBox, } from './miniflex';
+export { FlexBox, flexBoxLayout, FlexElement, resolvePaddingBox as resolveFlexPaddingBox, RootFlexBox, } from './miniflex';
+export type { CanvasBadgeProps, CanvasButtonProps, CanvasContainerProps, CanvasEmbedIconButtonProps, CanvasIconButtonProps, CanvasIconProps, CanvasRectProps, CanvasTextProps, RootBridgeProps, CanvasLinkProps, } from './components';
+export { buildCanvasTree, Canvas, RootBridge } from './components';
+export { useCanvasRegistry } from './hooks';

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

@@ -0,0 +1,79 @@
+import { Y as e, a$ as o, be as n, C as t, o as r, aB as C, aC as i, aD as v, p as l, aE as c, q as b, aF as I, aG as d, t as B, aH as g, u, aI as R, v as P, w as S, aK as x, b0 as m, x as N, F as h, l as p, ae as w, bw as A, R as D, ah as H, ai as T, bx as E, b1 as L, aP as _, bf as f, b2 as k, aQ as F, y as O, z as V, bg as y, an as z, ao as W, aq as q, ar as G, as as U, m as Y, b3 as Z, b4 as K, bh as M, M as j, N as J, O as Q, b5 as X, b6 as $, b7 as aa, bi as sa, bj as ea, bk as oa, A as na, b8 as ta, bm as ra, U as Ca, aY as ia, aZ as va, V as la, bn as ca, W as ba, X as Ia, b9 as da, r as Ba, B as ga, ba as ua, bb as Ra, s as Pa, g as Sa, bc as xa, bd as ma, bq as Na } from "../../../../chunks/TableGlide-B0WCOgRq.mjs";
+export {
+  e as BUTTON_PADDING_Y,
+  o as CANVAS_CELL_KIND,
+  n as CANVAS_PORTAL_EVENT,
+  t as Canvas,
+  r as CanvasAbsoluteContainer,
+  C as CanvasBadge,
+  i as CanvasButton,
+  v as CanvasChevron,
+  l as CanvasContainer,
+  c as CanvasEmbedIconButton,
+  b as CanvasHoverController,
+  I as CanvasIcon,
+  d as CanvasIconButton,
+  B as CanvasLeaf,
+  g as CanvasLink,
+  u as CanvasNode,
+  R as CanvasRect,
+  P as CanvasRegistry,
+  S as CanvasRoot,
+  x as CanvasText,
+  m as CellCanvasRoot,
+  N as DrawBatcher,
+  h as FlexBox,
+  p as FlexElement,
+  w as ICON_SIZE_ADJUSTMENT,
+  A as RootBridge,
+  D as RootFlexBox,
+  H as SIZE_CONFIG,
+  T as VIEW_COLORS,
+  E as buildCanvasTree,
+  L as buildCellId,
+  _ as canvasCellRenderer,
+  f as clearIconCache,
+  k as createCanvasCell,
+  F as createCanvasCellRenderer,
+  O as createNormalCanvasInteraction,
+  V as defaultBatcher,
+  y as dispatchCanvasPortalHover,
+  z as drawButton,
+  W as drawButtonWithView,
+  q as drawIcon,
+  G as drawIconButton,
+  U as drawIconButtonWithView,
+  Y as flexBoxLayout,
+  Z as getCellIndices,
+  K as getHoverState,
+  M as getIconCacheSize,
+  j as getIconImageDirect,
+  J as getIconSprite,
+  Q as getIconSpriteStats,
+  X as isCanvasCell,
+  $ as isHoveringBounds,
+  aa as isPointInArea,
+  sa as isPortalHoverLocked,
+  ea as isReactIcon,
+  oa as lockPortalHover,
+  na as normalizeCanvasInteraction,
+  ta as normalizeHoverPoint,
+  ra as normalizeIcon,
+  Ca as onAnyIconLoad,
+  ia as performCanvasClick,
+  va as performCanvasPointerDownIntent,
+  la as preloadIconSprites,
+  ca as reactIconToSvg,
+  ba as registerIconDefinitions,
+  Ia as resetIconSpriteCache,
+  da as resolveClickPoint,
+  Ba as resolveFlexPaddingBox,
+  ga as resolvePaddingBox,
+  ua as retrieveRenderData,
+  Ra as storeRenderData,
+  Pa as subscribeToCanvasPortalHover,
+  Sa as subscribeToPortalHoverLock,
+  xa as toRelativePoint,
+  ma as updateHoverState,
+  Na as useCanvasRegistry
+};