@funnest/charts 0.0.0-stage → 0.1.0

package/dist/indicators/definitions.d.ts

@@ -0,0 +1,74 @@
+import type { Locale } from '../model/time-format';
+import type { Bar } from '../types';
+export type IndicatorType = 'ma' | 'ema' | 'bb' | 'rsi' | 'macd';
+/** Which price an indicator reads from each bar. */
+export type PriceSource = 'close' | 'open' | 'high' | 'low' | 'hl2' | 'hlc3' | 'ohlc4';
+export declare const PRICE_SOURCES: {
+    value: PriceSource;
+    label: Record<Locale, string>;
+}[];
+/** One moving-average line: period + source. Its color/width/visibility live in the config's `styles`. */
+export interface MaLine {
+    period: number;
+    source: PriceSource;
+}
+export type IndicatorParamValue = number | string | MaLine[];
+export type IndicatorParams = Record<string, IndicatorParamValue>;
+export interface IndicatorParamSpec {
+    key: string;
+    label: Record<Locale, string>;
+    /** 'lines' = a list of {period, source} rows (moving averages). */
+    kind: 'number' | 'source' | 'lines';
+    min?: number;
+    max?: number;
+    step?: number;
+}
+/** Per-series overrides set by the user. */
+export interface SeriesStyle {
+    color?: string;
+    /** Line width in CSS px. */
+    width?: number;
+    visible?: boolean;
+}
+export interface IndicatorSeries {
+    key: string;
+    label: string;
+    values: Float64Array;
+    /** Ignored for histograms, which are colored up/down by sign. */
+    color: string;
+    width: number;
+    visible: boolean;
+    kind: 'line' | 'histogram';
+}
+export interface IndicatorOutput {
+    series: IndicatorSeries[];
+    /** Shaded area between two series (Bollinger band). */
+    fill?: {
+        upper: string;
+        lower: string;
+        color: string;
+    };
+    /** Horizontal reference lines (RSI 30/70). */
+    levels?: number[];
+    /** Fixed value range instead of auto-scaling (RSI 0–100). */
+    range?: [number, number];
+    /** Decimals for labels; null = the symbol's price precision. */
+    precision: number | null;
+}
+export interface IndicatorDefinition {
+    type: IndicatorType;
+    name: Record<Locale, string>;
+    description: Record<Locale, string>;
+    /** Drawn over the candles (true) or in its own pane below (false). */
+    overlay: boolean;
+    params: IndicatorParamSpec[];
+    defaults: IndicatorParams;
+    title(params: IndicatorParams): string;
+    compute(bars: readonly Bar[], params: IndicatorParams): IndicatorOutput;
+}
+/** Distinct line colors that avoid the up/down candle colors. */
+export declare const SERIES_COLORS: string[];
+export declare function priceSource(bars: readonly Bar[], source?: PriceSource): Float64Array;
+/** Reads `lines`, accepting the legacy `periods: number[]` shape too. */
+export declare function maLines(p: IndicatorParams): MaLine[];
+export declare const INDICATORS: Record<IndicatorType, IndicatorDefinition>;

package/dist/indicators/manager.d.ts

@@ -0,0 +1,26 @@
+import type { Bar } from '../types';
+import { type IndicatorOutput, type IndicatorParams, type IndicatorType, type SeriesStyle } from './definitions';
+export interface IndicatorConfig {
+    id: string;
+    type: IndicatorType;
+    params: IndicatorParams;
+    /** Hidden indicators keep their pane and legend but draw nothing. Default true. */
+    visible?: boolean;
+    /** Per-series color/width/visibility, keyed by series key (MA rows: 'l0', 'l1', …). */
+    styles?: Record<string, SeriesStyle>;
+}
+export type IndicatorPatch = Partial<Pick<IndicatorConfig, 'params' | 'visible' | 'styles'>>;
+/** Indicator instances plus a cache of computed series keyed by data version + settings. */
+export declare class IndicatorManager {
+    list: IndicatorConfig[];
+    private readonly cache;
+    add(type: IndicatorType, params?: IndicatorParams): string;
+    remove(id: string): boolean;
+    update(id: string, patch: IndicatorPatch): boolean;
+    set(configs: readonly IndicatorConfig[]): void;
+    snapshot(): IndicatorConfig[];
+    get overlays(): IndicatorConfig[];
+    get panes(): IndicatorConfig[];
+    /** Computed series with user styles applied; recomputed only when data or settings change. */
+    output(cfg: IndicatorConfig, bars: readonly Bar[], dataVersion: number): IndicatorOutput;
+}

package/dist/indicators/math.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Indicator math over plain number arrays. Outputs are aligned with the input
+ * (same length); positions without enough data are NaN.
+ */
+export declare function sma(src: ArrayLike<number>, period: number): Float64Array;
+/** EMA seeded with the SMA of the first `period` valid values (leading NaNs are skipped). */
+export declare function ema(src: ArrayLike<number>, period: number): Float64Array;
+/** Rolling population standard deviation. */
+export declare function stdev(src: ArrayLike<number>, period: number): Float64Array;
+export declare function bollinger(src: ArrayLike<number>, period: number, mult: number): {
+    middle: Float64Array<ArrayBufferLike>;
+    upper: Float64Array<ArrayBuffer>;
+    lower: Float64Array<ArrayBuffer>;
+};
+/** Wilder's RSI. */
+export declare function rsi(src: ArrayLike<number>, period: number): Float64Array;
+export declare function macd(src: ArrayLike<number>, fast: number, slow: number, signal: number): {
+    macd: Float64Array<ArrayBuffer>;
+    signal: Float64Array<ArrayBufferLike>;
+    histogram: Float64Array<ArrayBuffer>;
+};

package/dist/interaction.d.ts

@@ -0,0 +1,81 @@
+import type { ObjectHit } from './objects/types';
+import type { PaneId } from './render/renderer';
+export interface HitRegion {
+    area: 'plot' | 'priceAxis' | 'timeAxis' | 'none';
+    pane: PaneId | null;
+}
+/** What the interaction layer needs from the chart. Kept narrow so gestures stay testable. */
+export interface InteractionHost {
+    hitTest(x: number, y: number): HitRegion;
+    plotWidth(): number;
+    setCrosshair(x: number, y: number, source: 'mouse' | 'touch'): void;
+    clearCrosshair(): void;
+    panTime(dx: number): void;
+    zoomTime(anchorX: number, factor: number): void;
+    /** Pans the price axis only if it is in manual (non-auto) mode. */
+    panPrice(pane: PaneId, dy: number): void;
+    scalePrice(pane: PaneId, factor: number): void;
+    resetPriceScale(pane: PaneId): void;
+    resetView(): void;
+    /** A drawing tool is armed: presses create drawings instead of panning. */
+    toolActive(): boolean;
+    hitObject(x: number, y: number, touch: boolean): ObjectHit | null;
+    drawAt(x: number, y: number): void;
+    drawPreview(x: number, y: number): void;
+    drawRelease(x: number, y: number, moved: boolean): void;
+    objectDown(hit: ObjectHit, x: number, y: number): void;
+    objectMove(x: number, y: number): void;
+    objectUp(moved: boolean): void;
+    /** Mouse hover over an object (or nothing) — e.g. to show a fill tooltip. */
+    hoverObject(hit: ObjectHit | null): void;
+    clearSelection(): void;
+}
+/**
+ * Unified mouse / touch / pen gestures on top of Pointer Events.
+ *
+ * Desktop: hover = crosshair, drag = pan, wheel = zoom (trackpad pinch too), horizontal wheel = pan,
+ *          axis drag = axis scale, double-click = reset.
+ * Touch:   drag = pan with inertia, pinch = zoom, long-press = crosshair (magnet to close),
+ *          double-tap = reset. Vertical swipes are left to the page (`touch-action: pan-y`).
+ */
+export declare class Interaction {
+    private readonly host;
+    private readonly el;
+    private readonly pointers;
+    private mode;
+    private touch;
+    private moved;
+    private start;
+    private last;
+    private region;
+    private longPressTimer;
+    private samples;
+    private kineticFrame;
+    private pinchDistance;
+    private pinchMid;
+    private lastTap;
+    private readonly cleanups;
+    constructor(host: InteractionHost, el: HTMLElement);
+    destroy(): void;
+    private listen;
+    private local;
+    private onPointerDown;
+    private onLongPress;
+    private onPointerMove;
+    private onPointerUp;
+    private onPointerCancel;
+    private onPointerLeave;
+    private hover;
+    private pan;
+    private handleTap;
+    private pinchPoints;
+    private beginPinch;
+    private updatePinch;
+    private endPinch;
+    private startKinetic;
+    private stopKinetic;
+    private onWheel;
+    private onDoubleClick;
+    private onTouchMove;
+    private onContextMenu;
+}

package/dist/model/bar-store.d.ts

@@ -0,0 +1,36 @@
+import type { Bar } from '../types';
+export type UpsertResult = 'append' | 'update' | 'ignored';
+/** Time-ordered bar series. Index 0 is the oldest bar. */
+export declare class BarStore {
+    private items;
+    get bars(): readonly Bar[];
+    get length(): number;
+    at(index: number): Bar | undefined;
+    first(): Bar | undefined;
+    last(): Bar | undefined;
+    set(bars: readonly Bar[]): void;
+    /** Adds older bars in front. Bars not strictly older than the current first bar are dropped. Returns the count added. */
+    prepend(bars: readonly Bar[]): number;
+    /**
+     * Newer than the last bar → append. Same time as any existing bar → update in place
+     * (late/out-of-order WebSocket messages can still correct a closed bar).
+     * Older time that doesn't exist → ignored (use `merge` to fill gaps).
+     */
+    upsert(bar: Bar): UpsertResult;
+    /**
+     * Merges a batch that may overlap, extend, or fill gaps in the series
+     * (e.g. bars re-fetched after a WebSocket reconnect). Incoming bars win on equal time.
+     */
+    merge(bars: readonly Bar[]): void;
+    /** Index of the bar containing `time` (largest bar.time <= time); -1 if before the first bar. */
+    indexAtOrBefore(time: number): number;
+    /**
+     * Fractional index for any timestamp: interpolated between bars, extrapolated
+     * beyond either end using `interval` (ms per bar). Lets drawings anchor to time.
+     */
+    indexFloatOfTime(time: number, interval: number): number;
+    /** Inverse of `indexFloatOfTime`. */
+    timeOfIndexFloat(index: number, interval: number): number;
+    /** Binary search for an exact timestamp; -1 when absent. */
+    indexOfTime(time: number): number;
+}

package/dist/model/price-scale.d.ts

@@ -0,0 +1,35 @@
+export interface PriceScaleMargins {
+    /** Fraction of pane height kept empty above the max price. */
+    top: number;
+    /** Fraction of pane height kept empty below the min price. */
+    bottom: number;
+}
+/** Vertical scale for one pane. y is relative to the pane's top. */
+export declare class PriceScale {
+    readonly margins: PriceScaleMargins;
+    height: number;
+    /** Pixels reserved at the top for overlays (e.g. a legend); margins apply below it. */
+    insetTop: number;
+    autoScale: boolean;
+    private lo;
+    private hi;
+    constructor(margins: PriceScaleMargins);
+    get min(): number;
+    get max(): number;
+    setRange(min: number, max: number): void;
+    /** Height left after the inset (never less than half the pane, so tiny panes still show data). */
+    private get available();
+    private get innerTop();
+    private get innerHeight();
+    priceToY(price: number): number;
+    yToPrice(y: number): number;
+    /** Scales around the center. factor > 1 shows a wider price range. Disables auto-scale. */
+    zoom(factor: number): void;
+    /** Moves the content by `dy` pixels (positive = content moves down). Disables auto-scale. */
+    pan(dy: number): void;
+}
+/**
+ * "Nice" tick values (1/2/2.5/5 × 10ⁿ) covering [min, max] with at most ~maxCount ticks.
+ * `minStep` (e.g. the instrument's tick size) prevents sub-tick grid lines.
+ */
+export declare function niceTicks(min: number, max: number, maxCount: number, minStep?: number): number[];

package/dist/model/time-format.d.ts

@@ -0,0 +1,50 @@
+import type { Bar } from '../types';
+import type { TimeScale } from './time-scale';
+export type Locale = 'ko' | 'en';
+export interface TimeParts {
+    year: number;
+    /** 1–12 */
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+    second: number;
+    /** 0 = Sunday */
+    weekday: number;
+}
+export declare function defaultTimeZone(): string;
+/** Timezone-aware calendar parts with a per-timestamp cache (Intl is slow per call). */
+export declare class TimeFormatter {
+    readonly timeZone: string;
+    readonly locale: Locale;
+    private readonly dtf;
+    private readonly cache;
+    constructor(timeZone: string, locale: Locale);
+    parts(time: number): TimeParts;
+    /** Full label for the crosshair, e.g. "2026.11.09 (월) 14:30". */
+    crosshairLabel(time: number, intraday: boolean): string;
+    tickLabel(p: TimeParts, weight: number): string;
+}
+export declare const TickWeight: {
+    readonly Year: 60;
+    readonly Month: 50;
+    readonly Day: 40;
+    readonly Hour: 30;
+    readonly Minute30: 25;
+    readonly Minute15: 22;
+    readonly Minute5: 20;
+    readonly Minute: 10;
+    readonly None: 0;
+};
+/** How "important" the boundary between two consecutive bars is (bigger = coarser unit changed). */
+export declare function boundaryWeight(prev: TimeParts | null, cur: TimeParts): number;
+export interface TimeTick {
+    index: number;
+    x: number;
+    label: string;
+}
+/**
+ * Picks time-axis labels: most significant boundaries first (year > month > day > hour…),
+ * keeping at least `minGap` px between labels.
+ */
+export declare function computeTimeTicks(bars: readonly Bar[], timeScale: TimeScale, formatter: TimeFormatter, minGap: number): TimeTick[];

package/dist/model/time-scale.d.ts

@@ -0,0 +1,42 @@
+export interface TimeScaleOptions {
+    /** Pixels per bar. */
+    barSpacing: number;
+    minBarSpacing: number;
+    maxBarSpacing: number;
+    /** Empty space right of the last bar, in bars. */
+    rightOffset: number;
+}
+export declare const DEFAULT_TIME_SCALE_OPTIONS: TimeScaleOptions;
+export interface IndexRange {
+    from: number;
+    to: number;
+}
+/**
+ * Index-based horizontal scale: bars are evenly spaced regardless of time gaps
+ * (closed market hours collapse). `rightOffset` is stored relative to the last
+ * bar so appending keeps the realtime edge pinned and prepending history keeps
+ * the view still.
+ */
+export declare class TimeScale {
+    readonly options: TimeScaleOptions;
+    width: number;
+    barCount: number;
+    barSpacing: number;
+    rightOffset: number;
+    constructor(options?: TimeScaleOptions);
+    /** Logical (fractional) bar index at the right edge. */
+    get rightIndex(): number;
+    /** Center x of bar `index`. */
+    indexToX(index: number): number;
+    xToIndexFloat(x: number): number;
+    xToIndex(x: number): number;
+    /** Visible bar indices clamped to existing data. `to < from` when nothing is visible. */
+    visibleRange(): IndexRange;
+    pan(dx: number): void;
+    /** Zooms by `factor` keeping the bar under `anchorX` fixed. */
+    zoom(anchorX: number, factor: number): void;
+    reset(): void;
+    fitContent(): void;
+    /** Keeps at least a couple of bars on screen. */
+    clamp(): void;
+}

package/dist/objects/drawings.d.ts

@@ -0,0 +1,52 @@
+import { type AxisBadge, type ObjectHit, type ObjectRenderContext, type PaneCoords } from './types';
+export type DrawingType = 'trendline' | 'horizontal' | 'fibonacci';
+export interface DrawingPoint {
+    /** UTC ms — anchored to time, so drawings survive history loads and resolution changes. */
+    time: number;
+    price: number;
+}
+export interface Drawing {
+    id: string;
+    type: DrawingType;
+    points: DrawingPoint[];
+    color?: string;
+}
+export declare const DRAWING_POINTS: Record<DrawingType, number>;
+export declare const FIB_LEVELS: number[];
+export type DrawingsChange = 'preview' | 'commit' | 'tool' | 'selection';
+/**
+ * Owns drawings: creation (click-click or drag), selection, handle/body dragging,
+ * hit testing and rendering. Pure state + canvas; pointer routing lives in Interaction.
+ */
+export declare class DrawingManager {
+    private readonly onChange;
+    drawings: Drawing[];
+    tool: DrawingType | null;
+    selectedId: string | null;
+    private draft;
+    private drag;
+    constructor(onChange: (change: DrawingsChange) => void);
+    get selected(): Drawing | null;
+    setTool(tool: DrawingType | null): void;
+    select(id: string | null): void;
+    set(drawings: readonly Drawing[]): void;
+    update(id: string, patch: Partial<Omit<Drawing, 'id'>>): void;
+    remove(id: string): void;
+    clear(): void;
+    /** Esc: abort an in-progress drawing, else drop the tool, else deselect. */
+    cancel(): void;
+    createAt(c: PaneCoords, x: number, y: number): void;
+    /** Moves the not-yet-placed points (live preview while hovering or dragging). */
+    previewAt(c: PaneCoords, x: number, y: number): void;
+    /** Pointer released: a drag since the first point places the next one (drag-to-draw). */
+    releaseAt(c: PaneCoords, x: number, y: number, moved: boolean): void;
+    private finish;
+    hitTest(c: PaneCoords, x: number, y: number, tolerance: number): ObjectHit | null;
+    beginDrag(c: PaneCoords, id: string, part: 'body' | number, x: number, y: number): void;
+    dragTo(c: PaneCoords, x: number, y: number): void;
+    endDrag(moved: boolean): void;
+    private screenPoints;
+    private distance;
+    render(rc: ObjectRenderContext, badges: AxisBadge[]): void;
+    private renderOne;
+}

package/dist/objects/magnet.d.ts

@@ -0,0 +1,6 @@
+import type { Bar } from '../types';
+/**
+ * Magnet mode: the bar's open/high/low/close closest to pointer y (in pixels).
+ * Used so drawing points land exactly on candle extremes.
+ */
+export declare function snapToOhlc(bar: Bar, y: number, priceToY: (price: number) => number): number;

package/dist/objects/trading-sync.d.ts

@@ -0,0 +1,72 @@
+import type { SymbolInfo, Unsubscribe } from '../types';
+import type { ExecutionMarker, TradingLayer } from './trading';
+export interface PositionInfo {
+    price: number;
+    quantity: number;
+    side: 'long' | 'short';
+    label?: string;
+}
+export interface OrderInfo {
+    id: string;
+    price: number;
+    quantity: number;
+    side: 'buy' | 'sell';
+    /** e.g. "지정가", "STOP". */
+    label?: string;
+}
+export interface Execution extends ExecutionMarker {
+    /** Used to de-duplicate fills that arrive both from history and the live stream. */
+    id?: string;
+}
+export interface TradingCallbacks {
+    onExecution(execution: Execution): void;
+    onPositions(positions: PositionInfo[]): void;
+    onOrders(orders: OrderInfo[]): void;
+}
+/**
+ * The user's account data for the chart. Implement this once against your own backend
+ * (auth, broker API…); the chart handles loading per symbol, paging fills as history
+ * scrolls in, live updates and all the drawing/interaction.
+ */
+export interface TradingAdapter {
+    /** Fills within [from, to] (UTC ms). Called when a symbol loads and as older history pages in. */
+    getExecutions?(symbol: SymbolInfo, range: {
+        from: number;
+        to: number;
+    }): Promise<Execution[]>;
+    /** Open position(s) → average-price lines with live P&L. */
+    getPositions?(symbol: SymbolInfo): Promise<PositionInfo[]>;
+    /** Working orders → order lines. */
+    getOrders?(symbol: SymbolInfo): Promise<OrderInfo[]>;
+    /** Live account updates. Pass full position/order lists; fills one at a time. */
+    subscribe?(symbol: SymbolInfo, callbacks: TradingCallbacks): Unsubscribe;
+    /** Makes order lines draggable. Resolve `false` (or reject) to snap the line back. */
+    modifyOrder?(order: OrderInfo, price: number): void | boolean | Promise<void | boolean>;
+    /** Shows an × on order lines. Without `subscribe`, the line is removed once this resolves. */
+    cancelOrder?(order: OrderInfo): void | Promise<void>;
+}
+/** Mirrors a TradingAdapter's state for the current symbol into the TradingLayer. */
+export declare class TradingSync {
+    private readonly layer;
+    private readonly onError;
+    adapter: TradingAdapter | null;
+    private token;
+    private symbol;
+    private unsubscribe;
+    private positions;
+    private readonly orders;
+    private readonly executions;
+    private loadedFrom;
+    constructor(layer: TradingLayer, onError: (error: unknown) => void);
+    /** (Re)loads everything for a symbol whose bars start at `from`. */
+    load(symbol: SymbolInfo, from: number): Promise<void>;
+    /** Fetches fills for newly loaded older history (bars now start at `from`). */
+    loadOlder(from: number): Promise<void>;
+    reset(): void;
+    /** Drops the adapter's lines and stops updates (e.g. adapter removed, chart destroyed). */
+    detach(): void;
+    private setPositions;
+    private setOrders;
+    private orderOptions;
+    private addExecutions;
+}

package/dist/objects/trading.d.ts

@@ -0,0 +1,76 @@
+import type { Bar } from '../types';
+import { type AxisBadge, type ObjectHit, type ObjectRenderContext } from './types';
+export interface PositionLineOptions {
+    /** Average entry price. */
+    price: number;
+    quantity: number;
+    side: 'long' | 'short';
+    /** Overrides the default "평균단가" / "Avg" text. */
+    label?: string;
+}
+export interface OrderLineOptions {
+    price: number;
+    quantity: number;
+    side: 'buy' | 'sell';
+    /** Extra text such as "지정가" or "STOP". */
+    label?: string;
+    /**
+     * Called when the user drags the line to a new (tick-snapped) price. The line moves
+     * immediately; return `false` (or reject) to snap it back, e.g. when the broker refuses.
+     */
+    onMove?: (price: number) => void | boolean | Promise<void | boolean>;
+    /** Shows an × button on the label. */
+    onCancel?: () => void;
+}
+export interface ExecutionMarker {
+    time: number;
+    price: number;
+    side: 'buy' | 'sell';
+    quantity?: number;
+}
+/** Fills on the same bar and side, shown as one marker. */
+export interface ExecutionGroup {
+    key: string;
+    side: 'buy' | 'sell';
+    count: number;
+    quantity: number;
+    /** Quantity-weighted average price (plain average when quantities are missing). */
+    averagePrice: number;
+    /** Earliest fill time in the group. */
+    time: number;
+    x: number;
+    y: number;
+}
+export interface LineHandle<T> {
+    readonly id: string;
+    update(patch: Partial<T>): void;
+    remove(): void;
+}
+export interface TradingLabels {
+    buy: string;
+    sell: string;
+    position: string;
+}
+/** Position (average price) lines, draggable order lines and execution markers. */
+export declare class TradingLayer {
+    private readonly onChange;
+    private readonly positions;
+    private readonly orders;
+    private executions;
+    private labelRects;
+    private drag;
+    private groups;
+    constructor(onChange: () => void);
+    addPosition(options: PositionLineOptions): LineHandle<PositionLineOptions>;
+    addOrder(options: OrderLineOptions): LineHandle<OrderLineOptions>;
+    setExecutions(markers: readonly ExecutionMarker[]): void;
+    private handle;
+    get executionList(): readonly ExecutionMarker[];
+    executionGroup(key: string): ExecutionGroup | undefined;
+    hitTest(priceToY: (p: number) => number, x: number, y: number, tolerance: number): ObjectHit | null;
+    beginDrag(id: string): void;
+    dragTo(price: number): void;
+    endDrag(): void;
+    cancel(id: string): void;
+    render({ painter: p, coords: c, palette }: ObjectRenderContext, bars: readonly Bar[], barIndexAt: (time: number) => number, indexToX: (index: number) => number, labels: TradingLabels, badges: AxisBadge[]): void;
+}

package/dist/objects/types.d.ts

@@ -0,0 +1,42 @@
+import type { Painter } from '../render/painter';
+import type { Palette } from '../render/renderer';
+/** Coordinate helpers for objects living in the main price pane. */
+export interface PaneCoords {
+    plotWidth: number;
+    height: number;
+    timeToX(time: number): number;
+    /** Point under (x, y): time snapped to the nearest bar (extrapolated into the future), price to the tick size. */
+    pointAt(x: number, y: number): {
+        time: number;
+        price: number;
+    };
+    priceToY(price: number): number;
+    yToPrice(y: number): number;
+    snapPrice(price: number): number;
+    formatPrice(price: number): string;
+}
+export interface ObjectRenderContext {
+    painter: Painter;
+    coords: PaneCoords;
+    palette: Palette;
+}
+export type ObjectHit = {
+    kind: 'drawing';
+    id: string;
+    part: 'body' | number;
+} | {
+    kind: 'order';
+    id: string;
+    part: 'line' | 'cancel';
+} | {
+    kind: 'execution';
+    key: string;
+};
+/** A badge to draw on the price axis (collected so they render above axis labels). */
+export interface AxisBadge {
+    y: number;
+    text: string;
+    bg: string;
+    fg: string;
+}
+export declare const newId: (prefix: string) => string;

package/dist/price.d.ts

@@ -0,0 +1,17 @@
+import type { TickSize } from './types';
+/** Number of decimal places in a finite number (handles exponent notation like 1e-8). */
+export declare function decimalsOf(value: number): number;
+export declare function resolveTickSize(tickSize: TickSize, price: number): number;
+/**
+ * Round `price` to the nearest multiple of the tick size, avoiding float drift
+ * (e.g. 0.1 + 0.2) by working in scaled integers.
+ */
+export declare function roundToTick(price: number, tickSize: TickSize): number;
+/** KRX equity tick size table (effective 2023-01-25). */
+export declare function krxTickSize(price: number): number;
+export interface FormatPriceOptions {
+    thousandsSeparator?: boolean;
+}
+export declare function formatPrice(price: number, precision: number, { thousandsSeparator }?: FormatPriceOptions): string;
+/** Compact number for volumes: 1234567 → "123.5만" (ko) / "1.23M" (en). */
+export declare function formatCompact(value: number, locale?: 'ko' | 'en'): string;