@funnest/charts 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,4 @@
+Funnest Charts
+Copyright 2026 Funnest
+
+This product includes software developed by the Funnest Charts project.

package/README.md

@@ -1,3 +1,29 @@
-# Temporary Holding Version
+# @funnest/charts
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Canvas 차트 엔진 — 캔들, 지표, 실시간 연결 도구
+
+Canvas charting engine for financial charts: candles, indicators, realtime helpers.
+
+```bash
+npm i @funnest/charts
+```
+
+UI 없이 엔진만 쓸 때의 패키지예요. 툴바·검색·지표 UI까지 필요하면 `@funnest/charts-ui`(또는 React는 `@funnest/charts-react`)를 쓰세요.
+
+```ts
+import { createChart } from '@funnest/charts';
+
+const chart = createChart(document.getElementById('chart')!, { datafeed: myDatafeed });
+await chart.setSymbol('005930', '1D');
+```
+
+- 지표: MA, EMA, 볼린저 밴드, RSI, MACD
+- 실시간 도구: `ReconnectingWebSocket`, `TickAggregator`, `combineDatafeeds`, `monitorLatency`
+- 한국 시장 기본값: KST, KRX 장 시간·호가 단위(`krxTickSize`), 빨강 상승/파랑 하락
+- 거래소 연결 코드는 들어 있지 않아요. `Datafeed` 인터페이스로 직접 연결하세요.
+
+## 링크
+
+- 문서: https://charts.funnest.xyz/docs/
+- GitHub: https://github.com/funnest-xyz/funnest-charts
+- 라이선스: Apache-2.0

package/dist/chart.d.ts

@@ -0,0 +1,300 @@
+import { type Locale } from './model/time-format';
+import { TimeScale, type IndexRange, type TimeScaleOptions } from './model/time-scale';
+import { type IndicatorParams, type IndicatorType } from './indicators/definitions';
+import { type IndicatorConfig, type IndicatorPatch } from './indicators/manager';
+import { type Drawing, type DrawingType } from './objects/drawings';
+import { type ExecutionMarker, type LineHandle, type OrderLineOptions, type PositionLineOptions } from './objects/trading';
+import { type ChartSettings, type ChartState } from './settings';
+import { type TradingAdapter } from './objects/trading-sync';
+import { type ChartType, type CrosshairInfo, type PaneId } from './render/renderer';
+import { type ThemeTokens } from './theme';
+import type { Bar, ConnectionState, Datafeed, Quote, Resolution, SymbolInfo, TickSize } from './types';
+export interface ChartOptions {
+    /** Merged over the light theme. Values may use CSS variables: `{ background: 'var(--bg)' }`. */
+    theme?: Partial<ThemeTokens>;
+    locale?: Locale;
+    /** IANA timezone for axis labels. Defaults to the browser's; overridden by `SymbolInfo.timezone`. */
+    timezone?: string;
+    /**
+     * Show all times in this timezone regardless of the symbol's exchange (e.g. 'Asia/Seoul'
+     * for Korean users watching US stocks). Takes precedence over `timezone` and the symbol's.
+     */
+    displayTimezone?: string;
+    pricePrecision?: number;
+    tickSize?: TickSize;
+    /** Show the volume pane. Default true. (Same as `settings.volume`.) */
+    volume?: boolean;
+    /** Initial chart settings (high/low markers, grid, last price line, candle colors…). */
+    settings?: Partial<ChartSettings>;
+    timeScale?: Partial<TimeScaleOptions>;
+    /** Enables `setSymbol()` with automatic history paging and realtime updates. */
+    datafeed?: Datafeed;
+    /** Bars per history request. Default 300. */
+    historyBatchSize?: number;
+    /** The user's fills, positions and orders, synced per symbol. See TradingAdapter. */
+    trading?: TradingAdapter;
+}
+export interface ChartEvents {
+    crosshairMove: CrosshairInfo | null;
+    visibleRangeChange: IndexRange;
+    /** Manual-data mode: the user scrolled near the oldest bar. Respond with `prependData()`. */
+    needHistory: {
+        oldestTime: number;
+    };
+    symbolChange: SymbolInfo;
+    /** Bars changed (set / realtime update / history). Fired at most once per frame. */
+    dataChange: {
+        last: Bar | undefined;
+    };
+    /** Plot area geometry changed (resize, price-axis width). */
+    layoutChange: ChartLayout;
+    /** A symbol/resolution load started (true) or finished (false). */
+    loadingChange: boolean;
+    /** Drawings were created, edited or removed (not fired during a live drag). */
+    drawingsChange: Drawing[];
+    /** The armed drawing tool changed (null = cursor). Tools disarm after one drawing. */
+    drawingToolChange: DrawingType | null;
+    selectionChange: Drawing | null;
+    magnetChange: boolean;
+    chartTypeChange: ChartType;
+    settingsChange: ChartSettings;
+    /**
+     * Something worth persisting changed (symbol, interval, chart type, settings, indicators,
+     * drawings). Batched per tick — a good hook for autosaving `save()`.
+     */
+    stateChange: void;
+    /** Live market statistics from `Datafeed.subscribeQuotes`. */
+    quoteChange: Quote;
+    /** Realtime connection state/latency reported by the datafeed. */
+    connectionChange: ConnectionState;
+    indicatorsChange: IndicatorConfig[];
+    error: unknown;
+}
+export interface ChartPaneLayout {
+    id: PaneId;
+    kind: 'main' | 'volume' | 'indicator';
+    top: number;
+    height: number;
+}
+export interface IndicatorLegendItem {
+    id: string;
+    type: IndicatorType;
+    title: string;
+    overlay: boolean;
+    visible: boolean;
+    /** Visible series only. */
+    values: {
+        key: string;
+        label: string;
+        value: string;
+        color: string;
+    }[];
+}
+export interface ChartLayout {
+    width: number;
+    height: number;
+    plotWidth: number;
+    panesHeight: number;
+    timeAxisHeight: number;
+    /** Price pane, volume pane and one pane per non-overlay indicator, top to bottom. */
+    panes: ChartPaneLayout[];
+}
+/**
+ * Keeps the requested resolution when the symbol supports it; otherwise picks the closest
+ * supported one (preferring the next shorter), e.g. 3개월 → 1개월 on an exchange without 3M bars.
+ */
+export declare function fallbackResolution(requested: Resolution, supported: readonly Resolution[] | undefined): Resolution;
+export declare function createChart(container: HTMLElement, options?: ChartOptions): Chart;
+export declare class Chart {
+    readonly timeScale: TimeScale;
+    private readonly root;
+    private readonly mainLayer;
+    private readonly overlayLayer;
+    private readonly store;
+    private readonly mainScale;
+    private readonly volumeScale;
+    private readonly indicators;
+    private readonly indicatorScales;
+    private readonly emitter;
+    private readonly colors;
+    private readonly interaction;
+    private readonly cleanups;
+    private readonly drawings;
+    private readonly trading;
+    private readonly tradingSync;
+    private tooltipKey;
+    private chartType;
+    private magnet;
+    private objectDrag;
+    private theme;
+    private locale;
+    private formatter;
+    private pricePrecision;
+    private tickSize;
+    private settingsValue;
+    /** Drawings of symbols other than the current one (the current set lives in DrawingManager). */
+    private readonly drawingsBySymbol;
+    private stateQueued;
+    private readonly datafeed;
+    private readonly historyBatchSize;
+    private size;
+    private priceAxisWidth;
+    private frame;
+    private crosshair;
+    private lastCrosshairKey;
+    private lastRangeKey;
+    private lastLayoutKey;
+    private dataVersion;
+    private emittedDataVersion;
+    private rafId;
+    private mainDirty;
+    private destroyed;
+    private symbol;
+    private resolution;
+    private loadToken;
+    private unsubscribeBars;
+    private unsubscribeQuotes;
+    private latestQuote;
+    private connectionState;
+    private readonly displayTimezone;
+    private loadingHistory;
+    private noMoreHistory;
+    private historyRequestedFor;
+    constructor(container: HTMLElement, options?: ChartOptions);
+    /** Replaces all bars and scrolls to the latest. */
+    setData(bars: readonly Bar[]): void;
+    /** Realtime tick: same time as the last bar updates it, a newer time appends a bar. */
+    update(bar: Bar): void;
+    /** Adds older bars (history paging). The view stays where it is. */
+    prependData(bars: readonly Bar[], options?: {
+        noMoreData?: boolean;
+    }): void;
+    get bars(): readonly Bar[];
+    get symbolInfo(): SymbolInfo | null;
+    /** Loads a symbol through the datafeed, then follows realtime updates. */
+    setSymbol(symbol: string, resolution: Resolution): Promise<void>;
+    /** Latest market statistics (merged across partial updates), if the datafeed provides them. */
+    get quote(): Quote | null;
+    /** Realtime connection state, if the datafeed reports it. */
+    get connection(): ConnectionState | null;
+    get currentResolution(): Resolution | null;
+    /** Reloads the current symbol at another resolution. */
+    setResolution(resolution: Resolution): Promise<void>;
+    /** Plot geometry, for positioning overlays. */
+    get layout(): ChartLayout;
+    /**
+     * Reserves `px` at the top of the price pane so overlays (like a legend) never cover
+     * the candles. Auto-scaled data is laid out below the inset.
+     */
+    setTopInset(px: number): void;
+    /** factor > 1 zooms in. Anchored to the latest bar when it's on screen, otherwise to the center. */
+    zoom(factor: number): void;
+    /** Scrolls by a number of bars; positive moves toward newer bars. */
+    scrollBars(bars: number): void;
+    /** True when the newest bar is visible. */
+    isAtRealtime(): boolean;
+    /** Snapshot of the chart (without the crosshair) at device resolution. */
+    takeScreenshot(): HTMLCanvasElement;
+    /**
+     * Re-fetches the latest window and merges it in, keeping the view. Datafeeds trigger this
+     * via the `onResetCache` callback of subscribeBars after a WebSocket reconnect, so bars
+     * missed while disconnected are filled in.
+     */
+    private resync;
+    get type(): ChartType;
+    setChartType(type: ChartType): void;
+    get settings(): ChartSettings;
+    setSettings(patch: Partial<ChartSettings>): void;
+    /** Serializable snapshot of the layout. Pair with `load()`; see `stateChange` for autosave. */
+    save(): ChartState;
+    /**
+     * Restores a layout from `save()` (or JSON from storage — it's validated). Loads the saved
+     * symbol/interval through the datafeed first unless `{ symbol: false }`.
+     */
+    load(input: ChartState | unknown, options?: {
+        symbol?: boolean;
+    }): Promise<void>;
+    /** Swaps the active drawing set to `symbol`'s. */
+    private restoreDrawingsFor;
+    private stateChanged;
+    /** Arms a drawing tool (null = cursor). It disarms itself after one drawing is placed. */
+    setDrawingTool(tool: DrawingType | null): void;
+    get drawingTool(): DrawingType | null;
+    /** Magnet mode: drawing points snap to the nearest open/high/low/close of the bar. */
+    setMagnet(on: boolean): void;
+    get magnetEnabled(): boolean;
+    getDrawings(): Drawing[];
+    /** Restores drawings (e.g. from storage). */
+    setDrawings(drawings: readonly Drawing[]): void;
+    updateDrawing(id: string, patch: Partial<Omit<Drawing, 'id'>>): void;
+    removeDrawing(id: string): void;
+    clearDrawings(): void;
+    get selectedDrawing(): Drawing | null;
+    selectDrawing(id: string | null): void;
+    /** Adds an indicator (overlays draw on the candles, others get their own pane). Returns its id. */
+    addIndicator(type: IndicatorType, params?: IndicatorParams): string;
+    removeIndicator(id: string): void;
+    /** Changes params, per-series styles (color/width/visible) and/or overall visibility. */
+    updateIndicator(id: string, patch: IndicatorPatch): void;
+    setIndicatorVisible(id: string, visible: boolean): void;
+    getIndicators(): IndicatorConfig[];
+    /** Restores indicators (e.g. from storage). */
+    setIndicators(configs: readonly IndicatorConfig[]): void;
+    /** Formatted indicator values at a bar index (default: the last bar), for legends. */
+    indicatorLegend(index?: number): IndicatorLegendItem[];
+    private indicatorsChanged;
+    private indicatorScale;
+    /**
+     * Connects the user's account (fills, positions, orders). The chart loads them for the
+     * current symbol, pages older fills with history and applies live updates. Pass null to detach.
+     */
+    setTradingAdapter(adapter: TradingAdapter | null): void;
+    /** Average-price line with live P&L against the last price. */
+    addPositionLine(options: PositionLineOptions): LineHandle<PositionLineOptions>;
+    /** Pending order line. Pass `onMove` to make it draggable and `onCancel` for an × button. */
+    addOrderLine(options: OrderLineOptions): LineHandle<OrderLineOptions>;
+    /** Fill markers (▲ buy under the bar, ▼ sell above). Replaces the previous set. */
+    setExecutions(markers: readonly ExecutionMarker[]): void;
+    setTheme(theme: Partial<ThemeTokens>): void;
+    /** Re-reads CSS variables used by the theme (call after changing them outside of class/style attributes). */
+    refreshTheme(): void;
+    setLocale(locale: Locale): void;
+    setTimezone(timeZone: string): void;
+    setPriceFormat(format: {
+        precision?: number;
+        tickSize?: TickSize;
+    }): void;
+    setVolumeVisible(visible: boolean): void;
+    fitContent(): void;
+    scrollToRealtime(): void;
+    resetView(): void;
+    on<K extends keyof ChartEvents>(event: K, listener: (payload: ChartEvents[K]) => void): () => void;
+    destroy(): void;
+    /** Coalesces any number of changes into one paint per animation frame. */
+    private invalidate;
+    private render;
+    private renderModel;
+    /** Approximate ms per bar: the resolution when known, else the smallest recent gap. */
+    private barInterval;
+    private paneCoords;
+    private computeFrame;
+    /** Auto-scales the price pane to visible candles and overlay indicators; returns the candle extremes. */
+    private autoScale;
+    private autoScaleIndicator;
+    private resolvePalette;
+    private isIntraday;
+    private afterFrame;
+    private requestHistory;
+    private resolveCrosshair;
+    private paneAt;
+    private setTooltip;
+    private executionTooltip;
+    private emitCrosshair;
+    private paneScale;
+    private createInteractionHost;
+    /** Esc cancels a drawing in progress or deselects; Delete/Backspace removes the selected drawing. */
+    private observeKeyboard;
+    private observeSize;
+    /** Theme values using `var(--x)` follow the host page's dark-mode / theme switches automatically. */
+    private observeThemeVariables;
+}

package/dist/datafeed/combine.d.ts

@@ -0,0 +1,7 @@
+import type { Datafeed } from '../types';
+/**
+ * Serves several datafeeds through one chart. Symbols are namespaced as `KEY:SYMBOL`
+ * (e.g. 'UPBIT:KRW-BTC', 'BINANCE:BTCUSDT'); search merges every feed's results.
+ * A symbol without a prefix goes to the first feed.
+ */
+export declare function combineDatafeeds(feeds: Record<string, Datafeed>): Datafeed;

package/dist/datafeed/latency.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Periodically times an async probe (e.g. a tiny REST call) as a latency estimate, for venues
+ * whose WebSocket has no usable ping. Returns a stop function.
+ */
+export declare function monitorLatency(probe: () => Promise<unknown>, onLatency: (ms: number) => void, interval?: number): () => void;

package/dist/datafeed/socket.d.ts

@@ -0,0 +1,60 @@
+export type SocketStatus = 'connecting' | 'open' | 'reconnecting' | 'closed';
+export interface ReconnectingWebSocketOptions {
+    /** Runs on every (re)connect — send subscription messages here. `reconnected` is false the first time. */
+    onOpen?(socket: WebSocket, reconnected: boolean): void;
+    /** Text frames as-is; binary frames decoded as UTF-8 (Upbit sends binary JSON). */
+    onMessage(data: string): void;
+    onStatus?(status: SocketStatus): void;
+    /** First retry delay. Default 500ms; doubles each attempt with jitter. */
+    minDelay?: number;
+    /** Retry delay cap. Default 15s. */
+    maxDelay?: number;
+    /** Force a reconnect when nothing arrives for this long (half-open connections). 0 = off. */
+    idleTimeout?: number;
+    /**
+     * Application-level ping to measure round-trip latency (browsers can't send WS ping frames).
+     * Pong messages are consumed and not passed to `onMessage`.
+     */
+    ping?: {
+        interval: number;
+        message: () => string;
+        isPong: (data: string) => boolean;
+    };
+    onLatency?(ms: number): void;
+}
+/** Maps socket states onto the chart's ConnectionState vocabulary. */
+export declare const toConnectionStatus: (status: SocketStatus) => "connected" | "connecting" | "disconnected" | "reconnecting";
+/**
+ * WebSocket that never gives up: exponential backoff with jitter, immediate retry when the
+ * browser comes back online, and an optional idle watchdog. Pair `onOpen(…, reconnected)`
+ * with the datafeed's `onResetCache` so the chart refetches bars missed while disconnected.
+ */
+export declare class ReconnectingWebSocket {
+    private readonly url;
+    private readonly options;
+    private ws;
+    private attempt;
+    private everOpened;
+    private closed;
+    private retryTimer;
+    private idleTimer;
+    private pingTimer;
+    private pingSentAt;
+    private readonly onOnline;
+    constructor(url: string, options: ReconnectingWebSocketOptions);
+    get status(): SocketStatus;
+    /** Drops the current connection and reconnects right away (e.g. after the tab wakes up). */
+    reconnect(): void;
+    send(data: string): void;
+    close(): void;
+    private connect;
+    /**
+     * Abandons a socket and schedules the next attempt immediately. Doesn't wait for the
+     * close handshake: on a dead network the server never answers, and `close()` alone would
+     * leave us hanging with no `onclose` for a long time.
+     */
+    private drop;
+    private startPing;
+    private scheduleReconnect;
+    private armIdle;
+}

package/dist/events.d.ts

@@ -0,0 +1,7 @@
+export type Listener<T> = (payload: T) => void;
+export declare class Emitter<Events extends object> {
+    private readonly listeners;
+    on<K extends keyof Events>(event: K, listener: Listener<Events[K]>): () => void;
+    emit<K extends keyof Events>(event: K, payload: Events[K]): void;
+    clear(): void;
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export { Chart, createChart, fallbackResolution } from './chart';
+export { DEFAULT_CHART_SETTINGS, parseChartState } from './settings';
+export type { ChartSettings, ChartState } from './settings';
+export type { ChartEvents, ChartLayout, ChartOptions, ChartPaneLayout, IndicatorLegendItem } from './chart';
+export type { CrosshairInfo, PaneId } from './render/renderer';
+export type { Locale } from './model/time-format';
+export type { IndexRange, TimeScaleOptions } from './model/time-scale';
+export type { Bar, BarsRequest, BarsResult, Datafeed, Resolution, SymbolInfo, TickSize, Unsubscribe, SymbolType, SymbolSearchResult, Quote, ConnectionState, } from './types';
+export type { DirectionPreset, ThemeTokens } from './theme';
+export { createTheme, darkTheme, lightTheme } from './theme';
+export type { FormatPriceOptions } from './price';
+export { decimalsOf, formatCompact, formatPrice, krxTickSize, resolveTickSize, roundToTick } from './price';
+export { isIntradayResolution, resolutionToMs } from './resolution';
+export type { ChartType } from './render/renderer';
+export type { Drawing, DrawingPoint, DrawingType } from './objects/drawings';
+export { FIB_LEVELS } from './objects/drawings';
+export { snapToOhlc } from './objects/magnet';
+export type { ExecutionGroup, ExecutionMarker, LineHandle, OrderLineOptions, PositionLineOptions } from './objects/trading';
+export type { Execution, OrderInfo, PositionInfo, TradingAdapter, TradingCallbacks } from './objects/trading-sync';
+export { bucketStart, TickAggregator, timeZoneOffset } from './realtime';
+export type { Tick } from './realtime';
+export { INDICATORS, SERIES_COLORS } from './indicators/definitions';
+export type { IndicatorDefinition, IndicatorOutput, IndicatorParams, IndicatorParamSpec, IndicatorSeries, IndicatorType, } from './indicators/definitions';
+export type { IndicatorConfig, IndicatorPatch } from './indicators/manager';
+export { maLines, PRICE_SOURCES, priceSource } from './indicators/definitions';
+export type { MaLine, PriceSource, SeriesStyle } from './indicators/definitions';
+/** Indicator math, reusable in strategy/backtest code. */
+export { bollinger, ema, macd, rsi, sma, stdev } from './indicators/math';
+export { sessionStatus } from './session';
+export type { SessionStatus } from './session';
+/** Exchange-agnostic realtime helpers for writing your own Datafeed. */
+export { ReconnectingWebSocket, toConnectionStatus } from './datafeed/socket';
+export type { ReconnectingWebSocketOptions, SocketStatus } from './datafeed/socket';
+export { monitorLatency } from './datafeed/latency';
+export { combineDatafeeds } from './datafeed/combine';