@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/chart/_shared/core/data/encode.d.ts

@@ -0,0 +1,40 @@
+import { type Dataset } from './dataset';
+export type DatasetEncodeFamily = 'line' | 'area' | 'column' | 'bar' | 'scatter';
+export interface DatasetEncode {
+    x?: string | number;
+    y?: string | number;
+    z?: string | number;
+    itemName?: string | number;
+    tooltip?: ReadonlyArray<string | number>;
+    seriesName?: string;
+}
+export interface EncodedSeries {
+    name: string;
+    values: Array<number | null> | Array<{
+        x: number;
+        y: number | null;
+        z?: number;
+        name?: string;
+    }>;
+    xValues?: number[];
+    encode: {
+        x: string | undefined;
+        y: string | undefined;
+        z: string | undefined;
+        itemName: string | undefined;
+        tooltip: string[];
+    };
+}
+export interface EncodedDataset {
+    series: EncodedSeries[];
+    categories: string[];
+    xKind: 'number' | 'time' | 'ordinal' | 'index';
+}
+export declare function resolveEncodeDimensions(dataset: Dataset, encode: DatasetEncode | undefined): {
+    x: number | undefined;
+    y: number | undefined;
+    z: number | undefined;
+    itemName: number | undefined;
+    tooltip: number[];
+};
+export declare function encodeDataset(dataset: Dataset, encode: DatasetEncode | ReadonlyArray<DatasetEncode> | undefined, family: DatasetEncodeFamily): EncodedDataset;

package/dist/types/components/chart/_shared/core/data/index.d.ts

@@ -0,0 +1,4 @@
+export { cellText, cellToNumber, createDataset, datasetFromRows, detectArrayHeader, inferDimensionType, isEmptyCell, } from './dataset';
+export { applyTransform, applyTransforms, boxplotDataset, filterDataset, lttbIndices, matchesCondition, quantileSorted, regressionDataset, sampleDataset, sortDataset, summarizeBox, } from './transforms';
+export type { BoxplotOptions, BoxplotResult, BoxplotSummary, DatasetCondition, DatasetFieldCondition, DatasetSortKey, DatasetTransform, RegressionMethod, RegressionOptions, RegressionResult, SampleMethod, SampleOptions, } from './transforms';
+export type { Dataset, DatasetColumns, DatasetDimension, DatasetDimensionInput, DatasetDimensionType, DatasetPrimitive, DatasetRow, DatasetRowArray, DatasetRowObject, DatasetSourceInput, } from './dataset';

package/dist/types/components/chart/_shared/core/data/transforms.d.ts

@@ -0,0 +1,106 @@
+import { type Dataset, type DatasetPrimitive, type DatasetRowArray } from './dataset';
+export interface DatasetFieldCondition {
+    dimension: string | number;
+    eq?: DatasetPrimitive;
+    ne?: DatasetPrimitive;
+    gt?: number | string | Date;
+    gte?: number | string | Date;
+    lt?: number | string | Date;
+    lte?: number | string | Date;
+    in?: ReadonlyArray<DatasetPrimitive>;
+    notIn?: ReadonlyArray<DatasetPrimitive>;
+    contains?: string;
+    startsWith?: string;
+    regexp?: RegExp | string;
+    empty?: boolean;
+}
+export type DatasetCondition = DatasetFieldCondition | {
+    and: ReadonlyArray<DatasetCondition>;
+} | {
+    or: ReadonlyArray<DatasetCondition>;
+} | {
+    not: DatasetCondition;
+};
+export declare function matchesCondition(dataset: Dataset, row: DatasetRowArray, condition: DatasetCondition): boolean;
+export declare function filterDataset(dataset: Dataset, condition: DatasetCondition, id?: string): Dataset;
+export interface DatasetSortKey {
+    dimension: string | number;
+    order?: 'asc' | 'desc';
+}
+export declare function sortDataset(dataset: Dataset, keys: DatasetSortKey | ReadonlyArray<DatasetSortKey>, id?: string): Dataset;
+export type RegressionMethod = 'linear' | 'exponential' | 'logarithmic' | 'polynomial';
+export interface RegressionOptions {
+    method?: RegressionMethod;
+    dimensions?: readonly [
+        string | number,
+        string | number
+    ];
+    order?: number;
+    outputDimensions?: readonly [
+        string,
+        string
+    ];
+}
+export interface RegressionResult {
+    method: RegressionMethod;
+    parameters: number[];
+    rSquared: number;
+    expression: string;
+    points: Array<[
+        number,
+        number
+    ]>;
+    dataset: Dataset;
+}
+export declare function regressionDataset(dataset: Dataset, options?: RegressionOptions): RegressionResult;
+export interface BoxplotOptions {
+    dimension?: string | number;
+    groupBy?: string | number;
+    whisker?: number;
+    nameDimension?: string;
+}
+export interface BoxplotSummary {
+    name: string;
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+    outliers: number[];
+    count: number;
+}
+export interface BoxplotResult {
+    summaries: BoxplotSummary[];
+    dataset: Dataset;
+    outliers: Dataset;
+}
+export declare function quantileSorted(ascending: ReadonlyArray<number>, p: number): number;
+export declare function summarizeBox(name: string, values: ReadonlyArray<number>, whisker?: number): BoxplotSummary;
+export declare function boxplotDataset(dataset: Dataset, options?: BoxplotOptions): BoxplotResult;
+export type SampleMethod = 'lttb' | 'average' | 'max' | 'min' | 'sum' | 'first' | 'last';
+export interface SampleOptions {
+    method?: SampleMethod;
+    target?: number;
+    dimension?: string | number;
+    xDimension?: string | number;
+}
+export declare function lttbIndices(xs: ReadonlyArray<number>, ys: ReadonlyArray<number>, target: number): number[];
+export declare function sampleDataset(dataset: Dataset, options?: SampleOptions, id?: string): Dataset;
+export type DatasetTransform = {
+    type: 'filter';
+    config: DatasetCondition;
+} | {
+    type: 'sort';
+    config: DatasetSortKey | ReadonlyArray<DatasetSortKey>;
+} | {
+    type: 'regression';
+    config?: RegressionOptions;
+} | {
+    type: 'boxplot';
+    config?: BoxplotOptions;
+} | {
+    type: 'sample';
+    config?: SampleOptions;
+};
+export declare function applyTransform(dataset: Dataset, transform: DatasetTransform, id?: string): Dataset;
+export declare function applyTransforms(dataset: Dataset, transforms: ReadonlyArray<DatasetTransform>, id?: string): Dataset;

package/dist/types/components/chart/_shared/core/data/values-attribute.d.ts

@@ -0,0 +1,4 @@
+export type ParsedValuesAttribute = Float32Array | ReadonlyArray<unknown>;
+export declare function parseNumberList(text: string): Float32Array;
+export declare function parseValuesAttribute(text: string): ParsedValuesAttribute;
+export declare function parseCategoriesAttribute(text: string): string[];

package/dist/types/components/chart/_shared/core/drawing/drawing-contract.d.ts

@@ -0,0 +1,240 @@
+import { SEGMENT_TOOL } from './drawing-tools';
+export type DrawingSpace = 'data' | 'pixel';
+export interface DrawingAnchor {
+    x: number;
+    y: number;
+}
+export type DrawingDash = 'solid' | 'dashed' | 'dotted';
+export interface DrawingStyle {
+    color?: string;
+    width?: number;
+    dash?: DrawingDash;
+    opacity?: number;
+    fill?: string;
+    fillOpacity?: number;
+    fontSize?: number;
+}
+export type DrawingMeta = Readonly<Record<string, string | number | boolean>>;
+export interface ChartDrawing {
+    readonly id: string;
+    readonly tool: string;
+    readonly anchors: ReadonlyArray<DrawingAnchor>;
+    readonly space: DrawingSpace;
+    readonly visible: boolean;
+    readonly locked?: boolean;
+    readonly style?: DrawingStyle;
+    readonly options?: Readonly<Record<string, unknown>>;
+    readonly meta?: DrawingMeta;
+}
+export type DrawingAnchorInput = DrawingAnchor | {
+    x: number | string | Date;
+    y: number;
+} | readonly [
+    number | string | Date,
+    number
+];
+export interface ChartDrawingInput {
+    id?: string;
+    tool: string;
+    anchors: ReadonlyArray<DrawingAnchorInput>;
+    space?: DrawingSpace;
+    visible?: boolean;
+    locked?: boolean;
+    style?: DrawingStyle;
+    options?: Readonly<Record<string, unknown>>;
+    meta?: DrawingMeta;
+}
+export interface DrawingState {
+    readonly drawings: ReadonlyArray<ChartDrawing>;
+    readonly seed: number;
+}
+export declare const EMPTY_DRAWING_STATE: DrawingState;
+export declare function resolveDrawingAnchor(input: unknown): DrawingAnchor | null;
+export declare function resolveDrawingStyle(input: unknown): DrawingStyle | undefined;
+export declare function resolveDrawing(input: ChartDrawingInput, id: string): ChartDrawing | null;
+export type DrawingAction = {
+    type: 'add';
+    drawing: ChartDrawingInput;
+} | {
+    type: 'update';
+    id: string;
+    patch: Partial<Omit<ChartDrawing, 'id'>>;
+} | {
+    type: 'move';
+    id: string;
+    dx: number;
+    dy: number;
+} | {
+    type: 'anchor';
+    id: string;
+    index: number;
+    anchor: DrawingAnchor;
+} | {
+    type: 'anchors';
+    entries: ReadonlyArray<{
+        id: string;
+        anchors: ReadonlyArray<DrawingAnchor>;
+    }>;
+} | {
+    type: 'remove';
+    id: string;
+} | {
+    type: 'removeMany';
+    ids: ReadonlyArray<string>;
+} | {
+    type: 'clear';
+} | {
+    type: 'set';
+    drawings: ReadonlyArray<ChartDrawingInput>;
+};
+export type DrawingActionType = DrawingAction['type'];
+export declare function applyDrawingAction(state: DrawingState, action: DrawingAction): DrawingState;
+export declare function findDrawing(state: DrawingState, id: string): ChartDrawing | undefined;
+export declare const DRAWING_HISTORY_CAP = 100;
+export interface DrawingHistory {
+    readonly past: ReadonlyArray<DrawingState>;
+    readonly present: DrawingState;
+    readonly future: ReadonlyArray<DrawingState>;
+}
+export declare function createDrawingHistory(present?: DrawingState): DrawingHistory;
+export declare function historyApply(history: DrawingHistory, action: DrawingAction): DrawingHistory;
+export declare function historyUndo(history: DrawingHistory): DrawingHistory;
+export declare function historyRedo(history: DrawingHistory): DrawingHistory;
+export declare const canUndo: (history: DrawingHistory) => boolean;
+export declare const canRedo: (history: DrawingHistory) => boolean;
+export declare const DRAWING_SCHEMA_VERSION = 1;
+export interface DrawingDocument {
+    v: number;
+    seed: number;
+    drawings: ChartDrawing[];
+}
+export declare function drawingsToDocument(state: DrawingState): DrawingDocument;
+export declare function serializeDrawings(state: DrawingState): string;
+export declare function deserializeDrawings(input: string | unknown): DrawingState;
+export type ChartDrawingsInput = ReadonlyArray<ChartDrawingInput> | DrawingDocument | string | null | undefined;
+export declare function resolveDrawingsInput(input: ChartDrawingsInput): DrawingState;
+export type DrawingMode = 'none' | 'draw' | 'select';
+export type DrawingModeInput = DrawingMode | 'off' | 'true' | 'false' | boolean | null | undefined;
+export interface DrawingModeState {
+    mode: DrawingMode;
+    tool: string | null;
+}
+export declare const DEFAULT_DRAWING_TOOL = "segment";
+export declare function resolveDrawingMode(mode: DrawingModeInput, tool?: string | null): DrawingModeState;
+export type DrawingsChangeSource = 'draw' | 'api' | 'undo' | 'redo' | 'clear' | 'prop' | 'move' | 'keyboard';
+export interface DrawingAnchorsOverride {
+    id: string;
+    anchors: ReadonlyArray<DrawingAnchor>;
+}
+export interface DrawingsChangeEventDetail {
+    drawings: ChartDrawing[];
+    action: DrawingActionType | 'undo' | 'redo';
+    source: DrawingsChangeSource;
+    id?: string;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export declare function drawingsChangeDetail(history: DrawingHistory, action: DrawingsChangeEventDetail['action'], source: DrawingsChangeSource, id?: string): DrawingsChangeEventDetail;
+export type DrawingSelectionSource = 'click' | 'marquee' | 'api' | 'clear' | 'keyboard' | 'prune' | 'mode';
+export interface DrawingSelectionChangeEventDetail {
+    selected: string[];
+    source: DrawingSelectionSource;
+}
+export declare function sameDrawingSelection(a: ReadonlyArray<string>, b: ReadonlyArray<string>): boolean;
+export declare function pruneDrawingSelection(selected: ReadonlyArray<string>, state: DrawingState): ReadonlyArray<string>;
+export interface DrawingPixelPoint {
+    x: number;
+    y: number;
+}
+export interface DrawingPlotRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ResolvedDrawingStyle {
+    color: string;
+    width: number;
+    dash: DrawingDash;
+    opacity: number;
+    fill: string;
+    fillOpacity: number;
+    fontSize: number;
+}
+export declare const DRAWING_STYLE_DEFAULTS: Readonly<ResolvedDrawingStyle>;
+export declare function resolveDrawingStyleWithDefaults(style: DrawingStyle | undefined, defaults?: Readonly<ResolvedDrawingStyle>): ResolvedDrawingStyle;
+export type DrawingPrimitiveStyle = Partial<ResolvedDrawingStyle>;
+export type DrawingPrimitive = {
+    kind: 'line';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    role?: string;
+    style?: DrawingPrimitiveStyle;
+} | {
+    kind: 'polyline';
+    points: ReadonlyArray<DrawingPixelPoint>;
+    closed?: boolean;
+    role?: string;
+    style?: DrawingPrimitiveStyle;
+} | {
+    kind: 'rect';
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    role?: string;
+    style?: DrawingPrimitiveStyle;
+} | {
+    kind: 'circle';
+    cx: number;
+    cy: number;
+    r: number;
+    role?: string;
+    style?: DrawingPrimitiveStyle;
+} | {
+    kind: 'text';
+    x: number;
+    y: number;
+    text: string;
+    anchor?: 'start' | 'middle' | 'end';
+    baseline?: 'auto' | 'middle' | 'hanging';
+    role?: string;
+    style?: DrawingPrimitiveStyle;
+    width?: number;
+    height?: number;
+} | {
+    kind: 'path';
+    d: string;
+    role?: string;
+    style?: DrawingPrimitiveStyle;
+};
+export type DrawingTextMeasurer = (text: string, fontSize: number) => {
+    width: number;
+    height: number;
+};
+export interface DrawingRenderContext {
+    drawing: ChartDrawing;
+    points: ReadonlyArray<DrawingPixelPoint>;
+    plot: DrawingPlotRect;
+    style: ResolvedDrawingStyle;
+    measureText?: DrawingTextMeasurer;
+}
+export type DrawingPlacement = 'drag' | 'click' | 'free' | 'poly';
+export interface DrawingToolDefinition {
+    tool: string;
+    anchors: number | {
+        min: number;
+        max?: number;
+    };
+    placement: DrawingPlacement;
+    render(context: DrawingRenderContext): DrawingPrimitive[];
+}
+export declare function registerDrawingTool(definition: DrawingToolDefinition): DrawingToolDefinition;
+export declare function drawingTool(name: string): DrawingToolDefinition | undefined;
+export declare function hasDrawingTool(name: string): boolean;
+export declare function drawingToolNames(): string[];
+export declare function acceptsAnchorCount(definition: DrawingToolDefinition, count: number): boolean;
+export declare function placementAnchorCount(definition: DrawingToolDefinition): number;
+export { SEGMENT_TOOL };

package/dist/types/components/chart/_shared/core/drawing/drawing-cursor.d.ts

@@ -0,0 +1,9 @@
+import type { DrawingPixelPoint } from './drawing-contract';
+import type { RenderedDrawing } from './drawing-projection';
+export declare const DRAWING_HANDLE_HOVER_PX = 8;
+export declare const HANDLE_MIN_GAP_PX = 10;
+export type DrawingHoverTarget = 'handle' | 'body' | null;
+export declare function drawingHoverTarget(point: DrawingPixelPoint, rendered: ReadonlyArray<RenderedDrawing>, selection: ReadonlyArray<string>, tolerance?: number, handleRadius?: number): DrawingHoverTarget;
+export type DrawingCursorMode = 'select' | 'draw' | 'off';
+export declare function drawingCursor(mode: DrawingCursorMode, hover: DrawingHoverTarget, dragging: boolean): string;
+export declare function thinHandleIndices(points: ReadonlyArray<DrawingPixelPoint>, minGapPx?: number): number[];

package/dist/types/components/chart/_shared/core/drawing/drawing-export.d.ts

@@ -0,0 +1,11 @@
+import type { SvgLayer } from '../export/chart-export';
+export { composeSvgLayers, positionSvgLayer, svgDocumentFrame } from '../export/chart-export';
+export type { SvgLayer } from '../export/chart-export';
+export interface DrawingLayerSnapshot extends SvgLayer {
+    readonly count: number;
+}
+export declare function snapshotDrawingLayer(svg: SVGSVGElement | null, options?: {
+    plotX?: number;
+    plotY?: number;
+}): DrawingLayerSnapshot | null;
+export declare function drawingsFileBaseName(base: string): string;

package/dist/types/components/chart/_shared/core/drawing/drawing-hit.d.ts

@@ -0,0 +1,12 @@
+import type { DrawingPixelPoint, DrawingPlotRect, DrawingPrimitive } from './drawing-contract';
+import type { RenderedDrawing } from './drawing-projection';
+export declare const DEFAULT_HIT_TOLERANCE_PX = 6;
+export declare function textBox(primitive: Extract<DrawingPrimitive, {
+    kind: 'text';
+}>, fontSize?: number): DrawingPlotRect;
+export declare function hitTestPrimitive(point: DrawingPixelPoint, primitive: DrawingPrimitive, tolerance?: number, fontSize?: number): boolean;
+export declare function hitTestDrawing(point: DrawingPixelPoint, rendered: RenderedDrawing, tolerance?: number): boolean;
+export declare function pickDrawing(point: DrawingPixelPoint, rendered: ReadonlyArray<RenderedDrawing>, tolerance?: number): RenderedDrawing | null;
+export declare function primitiveIntersectsRect(primitive: DrawingPrimitive, rect: DrawingPlotRect): boolean;
+export declare function drawingsInRect(rect: DrawingPlotRect, rendered: ReadonlyArray<RenderedDrawing>): RenderedDrawing[];
+export declare function rectFromPoints(a: DrawingPixelPoint, b: DrawingPixelPoint): DrawingPlotRect;

package/dist/types/components/chart/_shared/core/drawing/drawing-interaction.d.ts

@@ -0,0 +1,79 @@
+import type { ChartDrawingInput, DrawingAnchor, DrawingAnchorsOverride, DrawingModeState, DrawingPixelPoint, DrawingPlotRect, DrawingSelectionSource, DrawingSpace } from './drawing-contract';
+import type { DrawingFrame, RenderedDrawing } from './drawing-projection';
+export declare const DRAWING_HANDLE_HIT_PX = 8;
+export interface DrawingPointerInput {
+    pointerId: number;
+    x: number;
+    y: number;
+    button?: number;
+    shiftKey?: boolean;
+    altKey?: boolean;
+    pointerType?: string;
+}
+export interface DrawingKeyInput {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+}
+export interface DrawingPreview {
+    tool: string;
+    space: DrawingSpace;
+    anchors: DrawingAnchor[];
+    points: DrawingPixelPoint[];
+}
+export interface DrawingInteractionHost {
+    frame(): DrawingFrame | undefined;
+    mode(): DrawingModeState;
+    space?(): DrawingSpace;
+    minDragPx?(): number;
+    commit(input: ChartDrawingInput): void;
+    preview(preview: DrawingPreview | null): void;
+    standDown(): void;
+    rendered?(): ReadonlyArray<RenderedDrawing>;
+    selection?(): ReadonlyArray<string>;
+    select?(ids: string[], source: DrawingSelectionSource): void;
+    marquee?(rect: DrawingPlotRect | null): void;
+    hitTolerancePx?(): number;
+    dragPreview?(entries: DrawingAnchorsOverride[] | null): void;
+    commitAnchors?(entries: DrawingAnchorsOverride[]): void;
+    remove?(ids: string[]): void;
+    undo?(): void;
+    redo?(): void;
+}
+export declare const POLY_CLOSE_PX = 8;
+export declare const POLY_MIN_VERTICES = 3;
+export declare const FREE_HAND_STEP_PX = 2;
+export declare class DrawingInteraction {
+    private readonly host;
+    private placement;
+    private suppressClick;
+    private hovering;
+    private selecting;
+    constructor(host: DrawingInteractionHost);
+    get isDragging(): boolean;
+    get dragsHandle(): boolean;
+    get isPending(): boolean;
+    get armed(): boolean;
+    pointerDown(input: DrawingPointerInput): boolean;
+    pointerMove(input: DrawingPointerInput): boolean;
+    private polyPointerUp;
+    private finishPoly;
+    pointerUp(input: DrawingPointerInput): boolean;
+    pointerCancel(): void;
+    private handleAt;
+    private selectPointerDown;
+    private lockToAxis;
+    private draggedAnchors;
+    private selectPointerMove;
+    private selectPointerUp;
+    private applySelection;
+    hover(input: DrawingPointerInput): boolean;
+    hoverEnd(): void;
+    keyDown(input: DrawingKeyInput): boolean;
+    consumeSuppressedClick(): boolean;
+    dispose(): void;
+    private isMeaningful;
+    private previewFor;
+}

package/dist/types/components/chart/_shared/core/drawing/drawing-measure.d.ts

@@ -0,0 +1,9 @@
+import type { DrawingTextMeasurer } from './drawing-contract';
+export declare const DRAWING_TEXT_FONT_FAMILY = "system-ui, sans-serif";
+export interface CachedDrawingTextMeasurer extends DrawingTextMeasurer {
+    clear(): void;
+    dispose(): void;
+}
+export declare const estimateTextSize: DrawingTextMeasurer;
+export declare function createCanvasTextMeasurer(family?: string, doc?: Document | undefined): CachedDrawingTextMeasurer;
+export declare function createSvgTextMeasurer(family?: string, doc?: Document | undefined, isActive?: () => boolean): CachedDrawingTextMeasurer;

package/dist/types/components/chart/_shared/core/drawing/drawing-projection.d.ts

@@ -0,0 +1,35 @@
+import type { ChartDrawing, DrawingAnchor, DrawingPixelPoint, DrawingPlotRect, DrawingPrimitive, DrawingSpace, DrawingState, DrawingTextMeasurer, ResolvedDrawingStyle } from './drawing-contract';
+export interface DrawingRenderExtras {
+    measureText?: DrawingTextMeasurer;
+    background?: string;
+}
+export interface DrawingScale {
+    (value: number): number;
+    invert: (pixel: number) => number;
+}
+export interface DrawingFrame {
+    plot: DrawingPlotRect;
+    xScale: DrawingScale;
+    yScale: DrawingScale;
+}
+export declare function projectDrawingAnchor(anchor: DrawingAnchor, frame: DrawingFrame, space: DrawingSpace): DrawingPixelPoint;
+export declare function anchorFromPixel(point: DrawingPixelPoint, frame: DrawingFrame, space: DrawingSpace): DrawingAnchor;
+export declare function projectDrawingAnchors(drawing: Pick<ChartDrawing, 'anchors' | 'space'>, frame: DrawingFrame): DrawingPixelPoint[];
+export declare function translatedDrawingAnchors(drawing: Pick<ChartDrawing, 'anchors' | 'space'>, dx: number, dy: number, frame: DrawingFrame): DrawingAnchor[];
+export declare function convertDrawingSpace(drawing: Pick<ChartDrawing, 'anchors' | 'space'>, frame: DrawingFrame, space: DrawingSpace): DrawingAnchor[];
+export declare const DRAWING_LABEL_CONTRAST = 5;
+export interface RenderedDrawing {
+    id: string;
+    tool: string;
+    drawing: ChartDrawing;
+    points: DrawingPixelPoint[];
+    style: ResolvedDrawingStyle;
+    primitives: DrawingPrimitive[];
+    unknownTool: boolean;
+    labelColor: string;
+}
+export declare function tintedBackground(fill: string, fillOpacity: number, background: string): string;
+export declare function renderDrawing(drawing: ChartDrawing, frame: DrawingFrame, extras?: DrawingRenderExtras): RenderedDrawing;
+export declare function renderDrawings(state: DrawingState, frame: DrawingFrame, extras?: DrawingRenderExtras): RenderedDrawing[];
+export declare function primitiveBounds(primitives: ReadonlyArray<DrawingPrimitive>): DrawingPlotRect | null;
+export declare function dashArrayFor(dash: ResolvedDrawingStyle['dash'], width: number): string | undefined;

package/dist/types/components/chart/_shared/core/drawing/drawing-tools.d.ts

@@ -0,0 +1,68 @@
+import type { DrawingPixelPoint, DrawingPlotRect, DrawingRenderContext, DrawingToolDefinition } from './drawing-contract';
+export type LineExtension = 'none' | 'ray' | 'both';
+export interface ExtendedLine {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export declare function extendLineToPlot(p0: DrawingPixelPoint, p1: DrawingPixelPoint, plot: DrawingPlotRect, mode: LineExtension): ExtendedLine | null;
+export declare function resolveLineExtension(value: unknown, fallback?: LineExtension): LineExtension;
+export declare const SEGMENT_TOOL: DrawingToolDefinition;
+export declare const TREND_LINE_TOOL: DrawingToolDefinition;
+export declare const RAY_TOOL: DrawingToolDefinition;
+export declare const EXTENDED_LINE_TOOL: DrawingToolDefinition;
+export declare function formatDrawingValue(value: number): string;
+export declare function levelLabel(context: DrawingRenderContext, axis: 'x' | 'y'): string;
+export declare const HORIZONTAL_LINE_TOOL: DrawingToolDefinition;
+export declare const HORIZONTAL_RAY_TOOL: DrawingToolDefinition;
+export declare const VERTICAL_LINE_TOOL: DrawingToolDefinition;
+export declare const CROSS_LINE_TOOL: DrawingToolDefinition;
+export declare function rectangleFromCorners(a: DrawingPixelPoint, b: DrawingPixelPoint): DrawingPlotRect | null;
+export declare const RECTANGLE_TOOL: DrawingToolDefinition;
+export declare const FIB_RETRACEMENT_LEVELS: ReadonlyArray<number>;
+export type FibExtend = 'none' | 'left' | 'right' | 'both';
+export declare function resolveFibLevels(value: unknown, fallback?: ReadonlyArray<number>): number[];
+export declare function resolveFibExtend(value: unknown): FibExtend;
+export declare function fibLevelLabel(level: number, value: number, showValues: boolean): string;
+export declare const FIB_RETRACEMENT_TOOL: DrawingToolDefinition;
+export declare const FREE_HAND_TOOL: DrawingToolDefinition;
+export type TextAlign = 'start' | 'middle' | 'end';
+export type TextValign = 'top' | 'middle' | 'bottom';
+export interface TextAnnotationLayout {
+    box: DrawingPlotRect;
+    lines: string[];
+    lineHeight: number;
+    padding: number;
+    align: TextAlign;
+}
+export declare const DEFAULT_TEXT_ANNOTATION = "Text";
+export declare const TEXT_ANNOTATION_PADDING = 4;
+export declare const TEXT_LINE_HEIGHT = 1.25;
+export declare function layoutTextAnnotation(context: DrawingRenderContext): TextAnnotationLayout | null;
+export declare const FIB_LABEL_MIN_GAP_PX = 12;
+export declare const TEXT_TOOL: DrawingToolDefinition;
+export type ArrowHead = 'end' | 'start' | 'both';
+export type ArrowLabelAt = 'start' | 'middle' | 'end';
+export declare const ARROW_HEAD_SIZE = 10;
+export declare const ARROW_HEAD_WIDTH_RATIO = 0.6;
+export interface ArrowHeadGeometry {
+    tip: DrawingPixelPoint;
+    base: DrawingPixelPoint;
+    corners: [
+        DrawingPixelPoint,
+        DrawingPixelPoint
+    ];
+}
+export declare const resolveArrowHead: (value: unknown) => ArrowHead;
+export declare const resolveArrowLabelAt: (value: unknown) => ArrowLabelAt;
+export declare function arrowHeadGeometry(from: DrawingPixelPoint, tip: DrawingPixelPoint, size?: number): ArrowHeadGeometry | null;
+export declare const ARROW_TOOL: DrawingToolDefinition;
+export declare const ELLIPSE_SEGMENTS = 64;
+export declare function ellipseOutline(cx: number, cy: number, rx: number, ry: number, segments?: number): DrawingPixelPoint[];
+export declare function polygonContains(points: ReadonlyArray<DrawingPixelPoint>, p: DrawingPixelPoint): boolean;
+export declare function polygonCentroid(points: ReadonlyArray<DrawingPixelPoint>): DrawingPixelPoint | null;
+export declare const ELLIPSE_TOOL: DrawingToolDefinition;
+export declare const CIRCLE_TOOL: DrawingToolDefinition;
+export declare const POLYGON_TOOL: DrawingToolDefinition;
+export declare const BUILT_IN_DRAWING_TOOLS: ReadonlyArray<DrawingToolDefinition>;

package/dist/types/components/chart/_shared/core/drawing/index.d.ts

@@ -0,0 +1,14 @@
+export { DEFAULT_DRAWING_TOOL, DRAWING_HISTORY_CAP, DRAWING_SCHEMA_VERSION, DRAWING_STYLE_DEFAULTS, EMPTY_DRAWING_STATE, SEGMENT_TOOL, acceptsAnchorCount, applyDrawingAction, canRedo, canUndo, createDrawingHistory, deserializeDrawings, drawingTool, drawingToolNames, drawingsChangeDetail, drawingsToDocument, findDrawing, hasDrawingTool, historyApply, historyRedo, historyUndo, placementAnchorCount, pruneDrawingSelection, registerDrawingTool, sameDrawingSelection, resolveDrawing, resolveDrawingAnchor, resolveDrawingMode, resolveDrawingStyle, resolveDrawingStyleWithDefaults, resolveDrawingsInput, serializeDrawings, } from './drawing-contract';
+export type { ChartDrawing, ChartDrawingInput, ChartDrawingsInput, DrawingAction, DrawingActionType, DrawingAnchor, DrawingAnchorInput, DrawingAnchorsOverride, DrawingDash, DrawingDocument, DrawingHistory, DrawingMeta, DrawingMode, DrawingModeInput, DrawingModeState, DrawingPixelPoint, DrawingPlacement, DrawingPlotRect, DrawingPrimitive, DrawingPrimitiveStyle, DrawingRenderContext, DrawingTextMeasurer, DrawingSelectionChangeEventDetail, DrawingSelectionSource, DrawingSpace, DrawingState, DrawingStyle, DrawingToolDefinition, DrawingsChangeEventDetail, DrawingsChangeSource, ResolvedDrawingStyle, } from './drawing-contract';
+export { anchorFromPixel, convertDrawingSpace, dashArrayFor, primitiveBounds, projectDrawingAnchor, projectDrawingAnchors, renderDrawing, renderDrawings, translatedDrawingAnchors, } from './drawing-projection';
+export type { DrawingFrame, DrawingRenderExtras, DrawingScale, RenderedDrawing } from './drawing-projection';
+export { BUILT_IN_DRAWING_TOOLS, CROSS_LINE_TOOL, EXTENDED_LINE_TOOL, FIB_RETRACEMENT_LEVELS, FIB_RETRACEMENT_TOOL, FREE_HAND_TOOL, HORIZONTAL_LINE_TOOL, HORIZONTAL_RAY_TOOL, ARROW_HEAD_SIZE, ARROW_HEAD_WIDTH_RATIO, ARROW_TOOL, CIRCLE_TOOL, ELLIPSE_SEGMENTS, ELLIPSE_TOOL, POLYGON_TOOL, RAY_TOOL, RECTANGLE_TOOL, TEXT_TOOL, TREND_LINE_TOOL, VERTICAL_LINE_TOOL, DEFAULT_TEXT_ANNOTATION, TEXT_ANNOTATION_PADDING, TEXT_LINE_HEIGHT, arrowHeadGeometry, ellipseOutline, extendLineToPlot, polygonCentroid, fibLevelLabel, formatDrawingValue, layoutTextAnnotation, levelLabel, rectangleFromCorners, resolveArrowHead, resolveArrowLabelAt, resolveFibExtend, resolveFibLevels, resolveLineExtension, } from './drawing-tools';
+export type { ArrowHead, ArrowHeadGeometry, ArrowLabelAt, ExtendedLine, FibExtend, LineExtension, TextAlign, TextAnnotationLayout, TextValign } from './drawing-tools';
+export { DRAWING_TEXT_FONT_FAMILY, createCanvasTextMeasurer, createSvgTextMeasurer, estimateTextSize } from './drawing-measure';
+export { DEFAULT_HIT_TOLERANCE_PX, drawingsInRect, hitTestDrawing, hitTestPrimitive, pickDrawing, rectFromPoints, textBox } from './drawing-hit';
+export { DRAWING_HANDLE_HIT_PX, DrawingInteraction, FREE_HAND_STEP_PX, POLY_CLOSE_PX, POLY_MIN_VERTICES } from './drawing-interaction';
+export { DRAWING_HANDLE_HOVER_PX, HANDLE_MIN_GAP_PX, drawingCursor, drawingHoverTarget, thinHandleIndices } from './drawing-cursor';
+export type { DrawingCursorMode, DrawingHoverTarget } from './drawing-cursor';
+export type { DrawingInteractionHost, DrawingKeyInput, DrawingPointerInput, DrawingPreview } from './drawing-interaction';
+export { composeSvgLayers, positionSvgLayer, svgDocumentFrame, snapshotDrawingLayer, drawingsFileBaseName } from './drawing-export';
+export type { DrawingLayerSnapshot, SvgLayer } from './drawing-export';