@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/chart/radar-chart/core/radar-stream-source.d.ts

@@ -0,0 +1,29 @@
+export type RadarStreamFrame = ReadonlyArray<number | null | undefined>;
+export type RadarChartStreamEvent = {
+    type: 'push';
+    count: 1;
+} | {
+    type: 'pushBatch';
+    count: number;
+} | {
+    type: 'shift';
+    count: number;
+} | {
+    type: 'replace';
+    count: number;
+};
+export interface RadarChartStreamSource {
+    push(frame: RadarStreamFrame): void;
+    pushBatch(frames: ReadonlyArray<RadarStreamFrame>): void;
+    shift(count: number): void;
+    replace(frames: ReadonlyArray<RadarStreamFrame>): void;
+    snapshot(window?: number): RadarStreamFrame[];
+    latest(): RadarStreamFrame | undefined;
+    subscribe(listener: (event: RadarChartStreamEvent) => void): () => void;
+    readonly length: number;
+}
+export interface CreateRadarStreamSourceOptions {
+    capacity: number;
+    initial?: ReadonlyArray<RadarStreamFrame>;
+}
+export { createRadarStreamSource } from "./radar-stream-source-runtime.ts";

package/dist/types/components/chart/radar-chart/core/radar-tooltip.d.ts

@@ -0,0 +1,57 @@
+import type { RadarChartPointerEventDetail } from './types.ts';
+export type RadarChartTooltipSide = 'top' | 'right' | 'bottom' | 'left';
+export type RadarChartTooltipTrigger = 'hover' | 'click' | 'hover-click';
+export type RadarChartTooltipOpenMode = 'single' | 'multiple';
+export type RadarChartTooltipStyleValue = string | number;
+export type RadarChartTooltipStyle = Record<string, RadarChartTooltipStyleValue>;
+export interface RadarChartTooltipConnectorSpec {
+    show: boolean;
+    color?: string;
+    width?: number;
+    dash?: number[];
+}
+export type RadarChartTooltipConnectorInput = undefined | null | boolean | Partial<RadarChartTooltipConnectorSpec>;
+export type RadarChartTooltipFormatContext = RadarChartPointerEventDetail;
+export interface RadarChartTooltipSpec {
+    show: boolean;
+    openMode: RadarChartTooltipOpenMode;
+    trigger: RadarChartTooltipTrigger;
+    side?: RadarChartTooltipSide;
+    offset: number;
+    format?: (detail: RadarChartPointerEventDetail, context?: RadarChartTooltipFormatContext) => string;
+    html?: (detail: RadarChartPointerEventDetail, context?: RadarChartTooltipFormatContext) => string;
+    className?: string;
+    style?: RadarChartTooltipStyle;
+    width?: number | string;
+    minWidth?: number | string;
+    maxWidth?: number | string;
+    padding?: number | string;
+    interactive: boolean;
+    hideOnLeave: boolean;
+    connector: RadarChartTooltipConnectorSpec;
+    draggable: boolean;
+}
+export type RadarChartTooltipObjectInput = Omit<Partial<RadarChartTooltipSpec>, 'connector'> & {
+    connector?: RadarChartTooltipConnectorInput;
+};
+export type RadarChartTooltipInput = undefined | null | 'auto' | 'off' | boolean | RadarChartTooltipObjectInput;
+export interface RadarChartTooltipShowEventDetail {
+    cssX: number;
+    cssY: number;
+    anchor: RadarChartTooltipSide;
+    text: string;
+    html?: string;
+    context?: RadarChartTooltipFormatContext;
+}
+export interface RadarChartTooltipActionEventDetail extends RadarChartTooltipFormatContext {
+    action: string;
+    text: string;
+    html?: string;
+}
+export declare const RADAR_TOOLTIP_DEFAULTS: RadarChartTooltipSpec;
+export declare function resolveRadarTooltipConnectorSpec(input: RadarChartTooltipConnectorInput): RadarChartTooltipConnectorSpec;
+export declare function resolveRadarTooltipSpec(input: RadarChartTooltipInput): RadarChartTooltipSpec;
+export declare function radarTooltipSpecFromLegacy(opts: {
+    show: boolean;
+    format?: (detail: RadarChartPointerEventDetail) => string;
+}): RadarChartTooltipSpec;

package/dist/types/components/chart/radar-chart/core/types.d.ts

@@ -0,0 +1,104 @@
+import type { ChartUnavailableBehaviour } from '../../_shared/core/engine/types.ts';
+export type RadarChartVariant = 'line' | 'area';
+export type RadarChartEngineMode = 'auto' | 'standard' | 'pro';
+export type RadarChartEngineTier = 'standard';
+export type RadarChartUnavailableBehaviour = ChartUnavailableBehaviour;
+export type RadarChartEasing = 'linear' | 'ease-out' | 'ease-in' | 'ease-in-out';
+export type RadarChartAnimationType = 'initial' | 'update';
+export type RadarChartSeriesActiveTrigger = 'hover' | 'click' | 'custom';
+export type RadarGridShape = 'polygon' | 'circle';
+export interface RadarSeriesSpec {
+    readonly data: ReadonlyArray<number | null | undefined>;
+    readonly id?: string | number;
+    readonly name?: string;
+    readonly color?: string;
+    readonly variant?: RadarChartVariant;
+    readonly fillOpacity?: number;
+    readonly lineWidth?: number;
+    readonly pointColors?: ReadonlyArray<string | undefined>;
+    readonly visible?: boolean;
+}
+export type RadarChartData = ReadonlyArray<RadarSeriesSpec> | ReadonlyArray<number | null | undefined>;
+export interface RadarChartLayout {
+    readonly cx: number;
+    readonly cy: number;
+    readonly radius: number;
+    readonly startAngle: number;
+    readonly categoryCount: number;
+    readonly angleStep: number;
+}
+export interface RadarResolvedPoint {
+    readonly categoryIndex: number;
+    readonly value: number | null;
+    readonly rawValue: number | null;
+    readonly angle: number;
+    readonly x: number;
+    readonly y: number;
+    readonly fraction: number;
+    readonly revealProgress?: number;
+    readonly color?: string;
+}
+export interface RadarResolvedSeries {
+    readonly index: number;
+    readonly id: string;
+    readonly name: string;
+    readonly color: string;
+    readonly variant: RadarChartVariant;
+    readonly fillOpacity: number;
+    readonly lineWidth: number;
+    readonly pointColors?: ReadonlyArray<string | undefined>;
+    readonly visible: boolean;
+    readonly points: ReadonlyArray<RadarResolvedPoint>;
+}
+export interface RadarGridRing {
+    readonly value: number;
+    readonly radius: number;
+    readonly major: boolean;
+    readonly label?: string;
+}
+export interface RadarGridSpoke {
+    readonly categoryIndex: number;
+    readonly angle: number;
+    readonly x: number;
+    readonly y: number;
+    readonly label: string;
+    readonly labelX: number;
+    readonly labelY: number;
+    readonly labelAnchor: 'start' | 'middle' | 'end';
+}
+export interface RadarRadialAxisSpec {
+    readonly min: number | 'auto';
+    readonly max: number | 'auto';
+    readonly tickInterval: number | 'auto';
+    readonly showLabels: boolean;
+    readonly labelColor: string;
+    readonly labelFontSize: number;
+    readonly labelFormat?: string;
+}
+export interface RadarChartRenderResult {
+    readonly points: number;
+    readonly renderMs: number;
+}
+export interface RadarChartPointerEventDetail {
+    readonly seriesIndex: number;
+    readonly seriesId: string;
+    readonly seriesName: string;
+    readonly categoryIndex: number;
+    readonly category: string;
+    readonly value: number | null;
+    readonly fraction: number;
+    readonly cssX: number;
+    readonly cssY: number;
+}
+export declare function resolveRadarSeriesMeta(series: RadarSeriesSpec | ReadonlyArray<number | null | undefined>, index: number, fallbackColor: string): {
+    readonly id: string;
+    readonly name: string;
+    readonly color: string;
+    readonly variant: RadarChartVariant | undefined;
+    readonly fillOpacity: number | undefined;
+    readonly lineWidth: number | undefined;
+    readonly pointColors: ReadonlyArray<string | undefined> | undefined;
+    readonly visible: boolean;
+    readonly data: ReadonlyArray<number | null | undefined>;
+};
+export declare function normalizeRadarData(data: RadarChartData | undefined): RadarSeriesSpec[];

package/dist/types/components/chart/radar-chart/engines/standard/index.d.ts

@@ -0,0 +1,84 @@
+import { pointOnCircle } from '../../core/radar-geometry.ts';
+import type { RadarChartLayout, RadarChartRenderResult, RadarGridRing, RadarGridShape, RadarGridSpoke, RadarResolvedSeries } from '../../core/types.ts';
+export interface RadarVisualStyle {
+    readonly gridColor: string;
+    readonly gridShape: RadarGridShape;
+    readonly spokeColor: string;
+    readonly showMarkers: boolean;
+    readonly markerRadius: number;
+    readonly ringLabelShow: boolean;
+    readonly ringLabelColor: string;
+    readonly ringLabelFontSize: number;
+    readonly categoryLabelColor: string;
+    readonly categoryLabelFontSize: number;
+}
+export interface PrepareRadarLayoutOptions {
+    readonly layout: RadarChartLayout;
+    readonly rings: ReadonlyArray<RadarGridRing>;
+    readonly spokes: ReadonlyArray<RadarGridSpoke>;
+    readonly series: ReadonlyArray<RadarResolvedSeries>;
+    readonly style: RadarVisualStyle;
+}
+export interface RadarGridRingVisual {
+    readonly key: string;
+    readonly path: string;
+    readonly value: number;
+    readonly label?: {
+        readonly x: number;
+        readonly y: number;
+        readonly text: string;
+        readonly color: string;
+        readonly fontSize: number;
+    };
+}
+export interface RadarSpokeVisual {
+    readonly key: string;
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly label: {
+        readonly x: number;
+        readonly y: number;
+        readonly text: string;
+        readonly anchor: 'start' | 'middle' | 'end';
+        readonly color: string;
+        readonly fontSize: number;
+    };
+}
+export interface RadarMarkerVisual {
+    readonly key: string;
+    readonly cx: number;
+    readonly cy: number;
+    readonly color: string;
+    readonly seriesIndex: number;
+    readonly categoryIndex: number;
+    readonly radius: number;
+    readonly opacity: number;
+}
+export interface RadarSeriesVisual {
+    readonly key: string;
+    readonly seriesIndex: number;
+    readonly id: string;
+    readonly name: string;
+    readonly color: string;
+    readonly variant: RadarResolvedSeries['variant'];
+    readonly fillOpacity: number;
+    readonly lineWidth: number;
+    readonly visible: boolean;
+    readonly linePath: string;
+    readonly fillPath: string;
+    readonly markers: ReadonlyArray<RadarMarkerVisual>;
+}
+export interface RadarRenderLayout {
+    readonly layout: RadarChartLayout;
+    readonly ringVisuals: ReadonlyArray<RadarGridRingVisual>;
+    readonly spokeVisuals: ReadonlyArray<RadarSpokeVisual>;
+    readonly seriesVisuals: ReadonlyArray<RadarSeriesVisual>;
+    readonly pointCount: number;
+}
+export declare function prepareRadarLayout(options: PrepareRadarLayoutOptions): RadarRenderLayout;
+export declare class RadarChartStandardRenderer {
+    draw(options: PrepareRadarLayoutOptions): RadarChartRenderResult;
+}
+export { pointOnCircle };

package/dist/types/components/chart/radar-chart/index.d.ts

@@ -0,0 +1,8 @@
+export * from './sy-radar-chart';
+export * from './core/types';
+export { pickRadarEngine, type PickRadarEngineOptions, type PickRadarEngineResult, } from './core/radar-chart-core';
+export { TWO_PI, toRadians, pointOnCircle, categoryAngle, valueToRadius, niceCeil, resolveRadarAxis, computeRadarRings, computeRadarLayout, radarSpokes, ringPath, resolveRadarSeries, seriesPolygonPath, nearestVertex, categoryForPoint, } from './core/radar-geometry';
+export { applyRadarEasing, createRadarAnimator, type RadarAnimator, type RadarTweenEntry, } from './core/radar-animator';
+export { createRadarStreamSource, type RadarChartStreamEvent, type RadarChartStreamSource, type RadarStreamFrame, type CreateRadarStreamSourceOptions, } from './core/radar-stream-source';
+export { RADAR_TOOLTIP_DEFAULTS, radarTooltipSpecFromLegacy, resolveRadarTooltipConnectorSpec, resolveRadarTooltipSpec, type RadarChartTooltipActionEventDetail, type RadarChartTooltipConnectorInput, type RadarChartTooltipConnectorSpec, type RadarChartTooltipFormatContext, type RadarChartTooltipInput, type RadarChartTooltipObjectInput, type RadarChartTooltipOpenMode, type RadarChartTooltipShowEventDetail, type RadarChartTooltipSide, type RadarChartTooltipSpec, type RadarChartTooltipStyle, type RadarChartTooltipStyleValue, type RadarChartTooltipTrigger, } from './core/radar-tooltip';
+export { RadarChartStandardRenderer, prepareRadarLayout, type RadarRenderLayout, type RadarVisualStyle, type PrepareRadarLayoutOptions, type RadarSeriesVisual, type RadarGridRingVisual, type RadarSpokeVisual, type RadarMarkerVisual, } from './engines/standard';

package/dist/types/components/chart/radar-chart/sy-radar-chart.d.ts

@@ -0,0 +1,262 @@
+import { EventEmitter } from '../../../stencil-public-runtime';
+import { type RadarChartAnimationType, type RadarChartData, type RadarChartEasing, type RadarChartEngineMode, type RadarChartEngineTier, type RadarChartPointerEventDetail, type RadarChartRenderResult, type RadarChartSeriesActiveTrigger, type RadarChartUnavailableBehaviour, type RadarChartVariant, type RadarGridShape } from './core/types';
+import { type RadarChartStreamSource, type RadarStreamFrame } from './core/radar-stream-source';
+import type { ChartEngineStatus } from '../_shared/core/engine/types';
+import { type RadarChartTooltipActionEventDetail, type RadarChartTooltipInput, type RadarChartTooltipShowEventDetail } from './core/radar-tooltip';
+import { type CartesianCrosshairEventDetail, type CartesianCrosshairInput } from '../_shared/core/contract';
+import { type LegendItem } from '../_shared/core/layout/legend';
+import { type ChartPointContextMenuEventDetail } from '../_shared/core/event';
+export type RadarChartLegendPosition = 'top' | 'bottom' | 'left' | 'right';
+export declare class SyRadarChart {
+    host: HTMLElement;
+    data: RadarChartData;
+    categories: string[];
+    min: number | 'auto';
+    max: number | 'auto';
+    tickInterval: number | 'auto';
+    width: number;
+    height: number;
+    brandLogo?: string;
+    brandPosition: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    variant: RadarChartVariant;
+    startAngle: number;
+    size?: number | string;
+    centerX?: number | string;
+    centerY?: number | string;
+    color: string;
+    colors?: ReadonlyArray<string>;
+    lineWidth: number;
+    fillOpacity: number;
+    gridShape: RadarGridShape;
+    gridColor: string;
+    showMarkers: boolean;
+    markerRadius: number;
+    showRingLabels: boolean;
+    ringLabelColor: string;
+    ringLabelFontSize: number;
+    ringLabelFormat?: string;
+    categoryLabelColor: string;
+    categoryLabelFontSize: number;
+    chartTitle?: string;
+    chartSubtitle?: string;
+    tooltipShow: boolean;
+    tooltipFormat?: (detail: RadarChartPointerEventDetail) => string;
+    tooltip?: RadarChartTooltipInput;
+    enableMouseTracking: boolean;
+    crosshair?: CartesianCrosshairInput;
+    legend: boolean;
+    legendPosition: RadarChartLegendPosition;
+    legendItems?: LegendItem[];
+    activeSeriesIndex?: number;
+    seriesActiveTrigger: RadarChartSeriesActiveTrigger;
+    animated: boolean;
+    animationDuration: number;
+    animationEasing: RadarChartEasing;
+    animationType?: RadarChartAnimationType;
+    editable: boolean;
+    streamSource?: RadarChartStreamSource;
+    streamWindow?: number;
+    streamMax?: number;
+    engine: RadarChartEngineMode;
+    proThreshold: number;
+    unavailable: RadarChartUnavailableBehaviour;
+    rendered: EventEmitter<RadarChartRenderResult & {
+        tier: RadarChartEngineTier;
+    }>;
+    pointClick: EventEmitter<RadarChartPointerEventDetail>;
+    pointHover: EventEmitter<RadarChartPointerEventDetail | null>;
+    crosshairMove: EventEmitter<CartesianCrosshairEventDetail | null>;
+    pointContextMenu: EventEmitter<ChartPointContextMenuEventDetail<RadarChartPointerEventDetail>>;
+    pointChange: EventEmitter<RadarChartPointerEventDetail>;
+    legendItemClick: EventEmitter<{
+        index: number;
+        seriesId: string;
+        label: string;
+        disabled: boolean;
+    }>;
+    seriesToggled: EventEmitter<{
+        index: number;
+        seriesId: string;
+        disabled: boolean;
+    }>;
+    appended: EventEmitter<{
+        count: number;
+    }>;
+    windowSlid: EventEmitter<{
+        dropped: number;
+    }>;
+    chartAnimationStart: EventEmitter<void>;
+    chartAnimationEnd: EventEmitter<void>;
+    chartAnimationInterrupted: EventEmitter<void>;
+    tooltipShown: EventEmitter<RadarChartTooltipShowEventDetail>;
+    tooltipHide: EventEmitter<void>;
+    tooltipAction: EventEmitter<RadarChartTooltipActionEventDetail>;
+    private activeTier;
+    private fallbackReason?;
+    private legendDisabled;
+    private radarTooltip;
+    private radarTooltips;
+    private radarCrosshair;
+    private srAnnouncement;
+    private animationTick;
+    private autoActiveSeriesIndex?;
+    private animator;
+    private animationFrameHandle;
+    private stopAnimationLoopImpl?;
+    private morphPrev;
+    private morphActive;
+    private morphStreaming;
+    private lastStreamEventAt?;
+    private internalStreamSource?;
+    private internalStreamCapacity?;
+    private boundStreamSource?;
+    private streamUnsubscribe?;
+    private readonly streamLicense;
+    private internalStreamData?;
+    private streamFrameIds;
+    private streamFrameSeq;
+    private suppressNextDataAnimation;
+    private lastRenderResult;
+    private pendingRenderedEmit;
+    private editingPoint;
+    private editingPointerTarget;
+    private editingPointerId;
+    private tooltipDrag?;
+    private tooltipElement?;
+    private nextTooltipId;
+    private draggableTooltipPositions;
+    private hasLoaded;
+    private detached;
+    connectedCallback(): void;
+    componentDidLoad(): void;
+    componentDidRender(): void;
+    disconnectedCallback(): void;
+    handleDataChange(_next: RadarChartData, prev: RadarChartData): void;
+    handleStreamSourceChange(): void;
+    handleAnimationToggle(): void;
+    handleSeriesActiveTriggerChange(): void;
+    handleVisualPropsChange(): void;
+    handleCrosshairChange(): void;
+    redraw(): Promise<RadarChartRenderResult>;
+    getActiveTier(): Promise<RadarChartEngineTier>;
+    setData(data: RadarChartData): Promise<void>;
+    addSeries(series: RadarChartData[number], opts?: {
+        insertAt?: number;
+    }): Promise<number>;
+    removeSeries(idOrIndex: string | number): Promise<boolean>;
+    updateSeries(idOrIndex: string | number, patch: Partial<RadarChartData[number]>): Promise<boolean>;
+    updatePoint(seriesIdOrIndex: string | number, categoryIdOrIndex: string | number, value: number | null): Promise<boolean>;
+    appendPoint(frame: RadarStreamFrame): Promise<void>;
+    appendBatch(frames: ReadonlyArray<RadarStreamFrame>): Promise<void>;
+    shift(count?: number): Promise<void>;
+    replace(frames: ReadonlyArray<RadarStreamFrame>): Promise<void>;
+    getStreamSource(): Promise<RadarChartStreamSource | undefined>;
+    setAnimation(options: {
+        duration?: number;
+        easing?: RadarChartEasing;
+        enabled?: boolean;
+        type?: RadarChartAnimationType;
+    }): Promise<void>;
+    pauseAnimation(): Promise<void>;
+    resumeAnimation(): Promise<void>;
+    replayAnimation(): Promise<void>;
+    hitTest(cssX: number, cssY: number): Promise<RadarChartPointerEventDetail | null>;
+    showTooltipAt(seriesIndex: number, categoryIndex: number): Promise<RadarChartPointerEventDetail | null>;
+    hideTooltip(): Promise<void>;
+    private now;
+    private prefersReducedMotion;
+    private shouldAnimate;
+    private shouldInitialAnimation;
+    private shouldUpdateAnimation;
+    private resolveAnimationType;
+    private hasAnimationBaseline;
+    private palette;
+    private resolvedActiveSeriesIndex;
+    private normalizedSeriesActiveTrigger;
+    private setAutoActiveSeriesIndex;
+    private resolveSeriesIndex;
+    private resolveCategoryIndex;
+    private effectiveCategories;
+    private numberFormatter;
+    private allValues;
+    private valuesForData;
+    private layoutForDraw;
+    private resolveSeriesForDraw;
+    private revealScaleFor;
+    private startReveal;
+    private displayedSeriesValuesFor;
+    private startMorph;
+    private currentRevealScale;
+    private morphDuration;
+    private startAnimationLoop;
+    private stopAnimationLoop;
+    private activeStreamSource;
+    private ensureInternalStreamSource;
+    private dropInternalStreamSource;
+    private bindStreamSource;
+    private handleStreamLicenseChange;
+    private noteStreamData;
+    private handleStreamEvent;
+    private streamSeriesFromFrames;
+    private dataMatchesStreamSeries;
+    private seriesMatchesStreamFrame;
+    private nextStreamFrameId;
+    private syncStreamFrameIds;
+    private initialStreamFrameIds;
+    private buildLegendItems;
+    private buildLegendLayout;
+    private titleGutter;
+    private plotRectFromLegend;
+    private onLegendItemClick;
+    private onLegendKeyDown;
+    private buildPointerDetail;
+    private emitPointChange;
+    private vertexPoint;
+    private nearestActiveAwareVertex;
+    private seriesVisualsForRender;
+    private tooltipHtml;
+    private plainTooltipText;
+    private effectiveTooltipSpec;
+    private hasVisibleTooltips;
+    private clearTooltips;
+    private shouldHideTooltipOnLeave;
+    private showTooltipForPoint;
+    private renderedTooltipForPoint;
+    private tooltipShowEventForRendered;
+    private refreshTooltipForPoint;
+    private tooltipStyleFromSpec;
+    private positionedRadarTooltip;
+    private tooltipAnchorFromTopLeft;
+    private tooltipTopLeftFromAnchor;
+    private tooltipTopLeftFromElement;
+    private tooltipAnchorFromPositionLock;
+    private tooltipPositionKey;
+    private rememberDraggableTooltipPosition;
+    private lockedTooltipPositionForDetail;
+    private lockedTooltipFromElement;
+    private updateRenderedTooltip;
+    private measureRadarTooltipBox;
+    private localPoint;
+    private onChartMove;
+    private onChartLeave;
+    private updateRadarCrosshair;
+    private clearRadarCrosshair;
+    private onChartClick;
+    private onPointContextMenu;
+    private onPointPointerDown;
+    private onChartPointerMove;
+    private onChartPointerUp;
+    private updateEditingPoint;
+    private clearHover;
+    private handleTooltipActionClick;
+    private handleTooltipPointerDown;
+    private handleTooltipPointerMove;
+    private handleTooltipPointerUp;
+    private accessibleSummary;
+    render(): any;
+    private renderRadarCrosshair;
+    private renderRadarTooltip;
+    private renderRadarTooltipItem;
+    private renderRadarTooltipConnector;
+    getEngineStatus(): Promise<ChartEngineStatus>;
+}

package/dist/types/components/chart/scatter-chart/core/animation/easing.d.ts

@@ -0,0 +1,2 @@
+export type ScatterChartEasing = 'linear' | 'ease-out' | 'ease-in' | 'ease-in-out';
+export declare function applyEasing(t: number, easing: ScatterChartEasing): number;

package/dist/types/components/chart/scatter-chart/core/animation/index.d.ts

@@ -0,0 +1,2 @@
+export { applyEasing, type ScatterChartEasing } from './easing';
+export { createScatterAnimator, type ScatterAnimationEntry, type ScatterAnimationFrameValue, type ScatterAnimationPhase, type ScatterAnimator, } from './scatter-animator';

package/dist/types/components/chart/scatter-chart/core/animation/scatter-animator.d.ts

@@ -0,0 +1,31 @@
+import { type ScatterChartEasing } from './easing.ts';
+export type ScatterAnimationPhase = 'enter' | 'exit';
+export interface ScatterAnimationEntry {
+    phase: ScatterAnimationPhase;
+    startedAt: number;
+    pausedElapsed: number;
+    paused: boolean;
+    easing: ScatterChartEasing;
+    duration: number;
+    delay?: number;
+    onComplete?: (key: string) => void;
+}
+export interface ScatterAnimationFrameValue {
+    phase: ScatterAnimationPhase;
+    rawProgress: number;
+    easedProgress: number;
+    scale: number;
+    alpha: number;
+}
+export interface ScatterAnimator {
+    start(key: string, entry: Omit<ScatterAnimationEntry, 'startedAt' | 'pausedElapsed' | 'paused'>): void;
+    pauseAll(now: number): void;
+    resumeAll(now: number): void;
+    valueAt(key: string, now: number): ScatterAnimationFrameValue | undefined;
+    tick(now: number): void;
+    hasActive(): boolean;
+    cancel(key: string): void;
+    clear(): void;
+    entries(): ReadonlyMap<string, ScatterAnimationEntry>;
+}
+export declare function createScatterAnimator(): ScatterAnimator;

package/dist/types/components/chart/scatter-chart/core/perf.d.ts

@@ -0,0 +1,15 @@
+import type { ScatterChartResolvedPoint } from './types.ts';
+export interface ScatterPointPool {
+    count: number;
+    slots: ScatterChartResolvedPoint[];
+}
+export declare function createScatterPointPool(initialCapacity?: number): ScatterPointPool;
+export declare function resetPool(pool: ScatterPointPool, expectedCapacity: number): void;
+export declare function acquireSlot(pool: ScatterPointPool): ScatterChartResolvedPoint;
+export declare function pointInPlotRect(cssX: number, cssY: number, radius: number, plot: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): boolean;
+export declare const SCATTER_CROP_THRESHOLD = 1000;

package/dist/types/components/chart/scatter-chart/core/scatter-chart-core.d.ts

@@ -0,0 +1,34 @@
+import type { ScatterChartEngineMode, ScatterChartEngineTier, ScatterChartUnavailableBehaviour } from './types';
+import type { ChartEngineCode } from '../../_shared/core/engine/types';
+export interface ScatterChartProFeatureOptions {
+    color?: string;
+    markerLineWidth?: number;
+    inactiveOtherPoints?: boolean;
+}
+export interface PickEngineOptions {
+    requested: ScatterChartEngineMode;
+    pointCount: number;
+    proThreshold: number;
+    onUnavailable: ScatterChartUnavailableBehaviour;
+    proAvailable: boolean;
+    proUnavailableReason?: string;
+    proUnavailableCode?: ChartEngineCode;
+    keepPro?: boolean;
+    features?: ScatterChartProFeatureOptions;
+}
+export interface PickEngineResult {
+    tier: ScatterChartEngineTier;
+    fallbackReason?: string;
+    featureFallbackReason?: string;
+    degradedReason?: string;
+    licenseReason?: string;
+}
+export type ProRgba = [
+    number,
+    number,
+    number,
+    number
+];
+export declare function pickEngine(opts: PickEngineOptions): PickEngineResult;
+export declare function getProFeatureBlockReason(features?: ScatterChartProFeatureOptions): string | undefined;
+export declare function parseProColor(input: string): ProRgba | null;

package/dist/types/components/chart/scatter-chart/core/scatter-draw-signature.d.ts

@@ -0,0 +1,16 @@
+import type { ScatterChartRenderInput } from './types';
+export interface ScatterDrawPixelState {
+    readonly pxWidth: number;
+    readonly pxHeight: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+}
+export declare function scatterDrawMemoEligible(input: ScatterChartRenderInput): boolean;
+export declare function scatterDrawSignature(input: ScatterChartRenderInput, px: ScatterDrawPixelState): ReadonlyArray<unknown> | null;
+export declare function sameScatterDrawSignature(a: ReadonlyArray<unknown> | null | undefined, b: ReadonlyArray<unknown> | null | undefined): boolean;
+export declare function scatterProjectionKey(plot: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, xProject: (v: number) => number, yProject: (v: number) => number, extra?: string): string;

package/dist/types/components/chart/scatter-chart/core/scatter-pro-renderer-loader.d.ts

@@ -0,0 +1,3 @@
+import type { ScatterChartRenderer } from './types';
+export declare const hasScatterChartProRenderer: boolean;
+export declare function createScatterChartProRenderer(_canvas: HTMLCanvasElement): ScatterChartRenderer | null;

package/dist/types/components/chart/scatter-chart/core/streaming/index.d.ts

@@ -0,0 +1 @@
+export { createScatterStreamSource, type CreateRingBufferSourceOptions, type ScatterChartStreamEvent, type ScatterChartStreamSource, } from './scatter-stream-source';

package/dist/types/components/chart/scatter-chart/core/streaming/scatter-stream-source-runtime.d.ts

@@ -0,0 +1,2 @@
+import { type CreateRingBufferSourceOptions, type ScatterChartStreamSource } from "./scatter-stream-source.ts";
+export declare function createScatterStreamSource(options: CreateRingBufferSourceOptions): ScatterChartStreamSource;