npm - @simahfud/klinecharts-pro - Versions diffs - 1.0.0 → 1.0.1 - Mend

@simahfud/klinecharts-pro 1.0.0 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -73,7 +73,7 @@ A professional-grade, TradingView-inspired charting component built on [KLineCha
 ### Using npm
 ```bash
-npm install klinecharts @klinecharts/pro
+npm install klinecharts @simahfud/klinecharts-pro
 ```
 ### Using unpkg or jsDelivr (CDN)
@@ -86,12 +86,12 @@ The library is published as a UMD bundle, so you can load it directly via `<scri
 <!-- KLineChart Pro -->
 <!-- using unpkg -->
-<script src="https://unpkg.com/@klinecharts/pro/dist/klinecharts-pro.umd.js"></script>
+<script src="https://unpkg.com/@simahfud/klinecharts-pro/dist/klinecharts-pro.umd.js"></script>
 <!-- OR using jsDelivr -->
-<script src="https://cdn.jsdelivr.net/npm/@klinecharts/pro/dist/klinecharts-pro.umd.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/@simahfud/klinecharts-pro/dist/klinecharts-pro.umd.js"></script>
 <!-- CSS styles (required) -->
-<link rel="stylesheet" href="https://unpkg.com/@klinecharts/pro/dist/klinecharts-pro.css" />
+<link rel="stylesheet" href="https://unpkg.com/@simahfud/klinecharts-pro/dist/klinecharts-pro.css" />
 ```
 After loading, the global variable `klinechartspro` is available:
@@ -100,13 +100,13 @@ After loading, the global variable `klinechartspro` is available:
 <!DOCTYPE html>
 <html>
 <head>
-  <link rel="stylesheet" href="https://unpkg.com/@klinecharts/pro/dist/klinecharts-pro.css" />
+  <link rel="stylesheet" href="https://unpkg.com/@simahfud/klinecharts-pro/dist/klinecharts-pro.css" />
 </head>
 <body>
   <div id="chart-container" style="width:100%;height:600px;"></div>
   <script src="https://unpkg.com/klinecharts/dist/klinecharts.min.js"></script>
-  <script src="https://unpkg.com/@klinecharts/pro/dist/klinecharts-pro.umd.js"></script>
+  <script src="https://unpkg.com/@simahfud/klinecharts-pro/dist/klinecharts-pro.umd.js"></script>
   <script>
     // Access via global: klinechartspro
     const { KLineChartPro, DefaultDatafeed } = klinechartspro
@@ -140,7 +140,7 @@ npm run build-core   # → dist/klinecharts-pro.umd.js + klinecharts-pro.js + kl
 ## 🚀 Quick Start
 ```typescript
-import { KLineChartPro, DefaultDatafeed } from 'klinecharts-pro'
+import { KLineChartPro, DefaultDatafeed } from '@simahfud/klinecharts-pro'
 const chart = new KLineChartPro({
   container: 'chart-container',
@@ -210,7 +210,7 @@ chart.stopReplay()
 **Programmatic control via `BarReplayManager`:**
 ```typescript
-import { BarReplayManager } from 'klinecharts-pro'
+import { BarReplayManager } from '@simahfud/klinecharts-pro'
 const replay = new BarReplayManager(chartWidget, datafeed)
@@ -255,7 +255,7 @@ chart.showStyleEditor('overlay_id_123')
 ### Keyboard Shortcuts
 ```typescript
-import { KeyboardShortcutManager } from 'klinecharts-pro'
+import { KeyboardShortcutManager } from '@simahfud/klinecharts-pro'
 const shortcuts = new KeyboardShortcutManager(containerElement)
@@ -274,7 +274,7 @@ shortcuts.destroy()
 ### Chart Templates
 ```typescript
-import { ChartTemplateManager } from 'klinecharts-pro'
+import { ChartTemplateManager } from '@simahfud/klinecharts-pro'
 const templates = new ChartTemplateManager(chartStore)
@@ -299,7 +299,7 @@ templates.deleteTemplate('My Scalping Setup')
 ### Crosshair Sync
 ```typescript
-import { CrosshairSyncManager } from 'klinecharts-pro'
+import { CrosshairSyncManager } from '@simahfud/klinecharts-pro'
 const sync = new CrosshairSyncManager()
@@ -314,7 +314,7 @@ sync.destroy()
 ### Custom Indicators & Overlays
 ```typescript
-import { registerCustomIndicator, registerCustomOverlay } from 'klinecharts-pro'
+import { registerCustomIndicator, registerCustomOverlay } from '@simahfud/klinecharts-pro'
 // Register a custom indicator (auto-appears in Indicator menu)
 registerCustomIndicator({
@@ -341,7 +341,7 @@ chart.removeAlert('alert1')
 ### Multi-Symbol Comparison
 ```typescript
-import { ComparisonManager } from 'klinecharts-pro'
+import { ComparisonManager } from '@simahfud/klinecharts-pro'
 const comparison = new ComparisonManager(chartWidget, datafeed)
 await comparison.addSymbol({ ticker: 'MSFT' }, period, from, to)
@@ -356,7 +356,7 @@ comparison.destroy()
 ## 📊 DefaultDatafeed
 ```typescript
-import { DefaultDatafeed } from 'klinecharts-pro'
+import { DefaultDatafeed } from '@simahfud/klinecharts-pro'
 // Uses Polygon.io API
 const datafeed = new DefaultDatafeed('YOUR_API_KEY')

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,556 @@
+import { Chart, DeepPartial, IndicatorTemplate, KLineData, Nullable, OverlayTemplate, Styles } from 'klinecharts';
+export interface SymbolInfo {
+	ticker: string;
+	name?: string;
+	shortName?: string;
+	exchange?: string;
+	market?: string;
+	pricePrecision?: number;
+	volumePrecision?: number;
+	priceCurrency?: string;
+	type?: string;
+	logo?: string;
+}
+export interface Period {
+	multiplier: number;
+	timespan: string;
+	text: string;
+}
+export type DatafeedSubscribeCallback = (data: KLineData) => void;
+export interface Datafeed {
+	searchSymbols(search?: string): Promise<SymbolInfo[]>;
+	getHistoryKLineData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<KLineData[]>;
+	subscribe(symbol: SymbolInfo, period: Period, callback: DatafeedSubscribeCallback): void;
+	unsubscribe(symbol: SymbolInfo, period: Period): void;
+}
+export interface PersistenceOptions {
+	enabled: boolean;
+	prefix?: string;
+}
+export type AlertCondition = "crosses_above" | "crosses_below" | "reaches";
+export interface AlertConfig {
+	id: string;
+	symbol: string;
+	condition: AlertCondition;
+	price: number;
+	message?: string;
+	triggered?: boolean;
+	callback?: () => void;
+}
+export interface CustomIndicatorConfig {
+	name: string;
+	category: "main" | "sub";
+	shortName?: string;
+	calcParams?: any[];
+	figures?: any[];
+	calc?: (kLineDataList: KLineData[], params: any) => any[];
+}
+export interface ChartProOptions {
+	container: string | HTMLElement;
+	styles?: DeepPartial<Styles>;
+	watermark?: string | Node;
+	theme?: string;
+	locale?: string;
+	drawingBarVisible?: boolean;
+	symbol: SymbolInfo;
+	period: Period;
+	periods?: Period[];
+	timezone?: string;
+	mainIndicators?: string[];
+	subIndicators?: string[];
+	datafeed: Datafeed;
+	persistence?: PersistenceOptions;
+	onError?: (error: Error) => void;
+}
+export interface ChartPro {
+	setTheme(theme: string): void;
+	getTheme(): string;
+	setStyles(styles: DeepPartial<Styles>): void;
+	getStyles(): Styles;
+	setLocale(locale: string): void;
+	getLocale(): string;
+	setTimezone(timezone: string): void;
+	getTimezone(): string;
+	setSymbol(symbol: SymbolInfo): void;
+	getSymbol(): SymbolInfo;
+	setPeriod(period: Period): void;
+	getPeriod(): Period;
+	ready?(): Promise<void>;
+	destroy?(): void;
+	setAlert?(alert: AlertConfig): void;
+	removeAlert?(id: string): void;
+	getAlerts?(): AlertConfig[];
+	addComparisonSymbol?(symbol: SymbolInfo): void;
+	removeComparisonSymbol?(ticker: string): void;
+	registerCustomIndicator?(config: CustomIndicatorConfig): void;
+	setChartType?(type: string): void;
+	getChartType?(): string;
+	startReplay?(dataSource: "current" | "custom"): void;
+	stopReplay?(): void;
+	showObjectTree?(): void;
+	showStyleEditor?(overlayId: string): void;
+}
+export type ConnectionStatus = "disconnected" | "connecting" | "connected" | "reconnecting";
+export type ConnectionStatusCallback = (status: ConnectionStatus) => void;
+export declare class DefaultDatafeed implements Datafeed {
+	constructor(apiKey: string);
+	private _apiKey;
+	private _prevSymbolMarket?;
+	private _prevSymbolTicker?;
+	private _ws?;
+	private _callback?;
+	private _connectionStatusCallback?;
+	private _reconnectAttempts;
+	private _maxReconnectAttempts;
+	private _reconnectTimer?;
+	private _currentSymbol?;
+	private _connectionStatus;
+	onConnectionStatusChange(callback: ConnectionStatusCallback): void;
+	getConnectionStatus(): ConnectionStatus;
+	private _setConnectionStatus;
+	searchSymbols(search?: string): Promise<SymbolInfo[]>;
+	getHistoryKLineData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<KLineData[]>;
+	subscribe(symbol: SymbolInfo, period: Period, callback: DatafeedSubscribeCallback): void;
+	unsubscribe(symbol: SymbolInfo, _period: Period): void;
+	destroy(): void;
+	private _connectWebSocket;
+	private _attemptReconnect;
+	private _cleanupWebSocket;
+}
+export declare class KLineChartPro implements ChartPro {
+	constructor(options: ChartProOptions);
+	private _container;
+	private _chartApi;
+	private _readyPromise;
+	private _readyResolve;
+	ready(): Promise<void>;
+	setTheme(theme: string): void;
+	getTheme(): string;
+	setStyles(styles: DeepPartial<Styles>): void;
+	getStyles(): Styles;
+	setLocale(locale: string): void;
+	getLocale(): string;
+	setTimezone(timezone: string): void;
+	getTimezone(): string;
+	setSymbol(symbol: SymbolInfo): void;
+	getSymbol(): SymbolInfo;
+	setPeriod(period: Period): void;
+	getPeriod(): Period;
+	destroy(): void;
+}
+export interface StoredPreferences {
+	theme?: string;
+	locale?: string;
+	timezone?: string;
+	symbol?: SymbolInfo;
+	period?: Period;
+	mainIndicators?: string[];
+	subIndicators?: string[];
+	styles?: Record<string, any>;
+	drawings?: Record<string, any[]>;
+	alerts?: AlertConfig[];
+}
+/**
+ * Persistence layer using localStorage.
+ * All keys are namespaced with the storage prefix to avoid collisions.
+ */
+export declare class ChartStore {
+	private _prefix;
+	private _enabled;
+	constructor(enabled?: boolean, prefix?: string);
+	private _key;
+	private _get;
+	private _set;
+	private _remove;
+	getTheme(): string | null;
+	setTheme(theme: string): void;
+	getLocale(): string | null;
+	setLocale(locale: string): void;
+	getTimezone(): string | null;
+	setTimezone(timezone: string): void;
+	getSymbol(): SymbolInfo | null;
+	setSymbol(symbol: SymbolInfo): void;
+	getPeriod(): Period | null;
+	setPeriod(period: Period): void;
+	getMainIndicators(): string[] | null;
+	setMainIndicators(indicators: string[]): void;
+	getSubIndicators(): Record<string, string> | null;
+	setSubIndicators(indicators: Record<string, string>): void;
+	getStyles(): Record<string, any> | null;
+	setStyles(styles: Record<string, any>): void;
+	getDrawings(ticker: string): any[] | null;
+	setDrawings(ticker: string, drawings: any[]): void;
+	getAlerts(): AlertConfig[];
+	setAlerts(alerts: AlertConfig[]): void;
+	addAlert(alert: AlertConfig): void;
+	removeAlert(id: string): void;
+	getAll(): StoredPreferences;
+	clear(): void;
+}
+export interface DrawingAction {
+	type: "add" | "remove" | "modify";
+	overlay: any;
+	previousState?: any;
+}
+/**
+ * Drawing persistence + undo/redo stack.
+ */
+export declare class DrawingStore {
+	private _store;
+	private _undoStack;
+	private _redoStack;
+	private _maxHistory;
+	constructor(store: ChartStore);
+	pushAction(action: DrawingAction): void;
+	canUndo(): boolean;
+	canRedo(): boolean;
+	undo(): DrawingAction | null;
+	redo(): DrawingAction | null;
+	saveDrawings(ticker: string, drawings: any[]): void;
+	loadDrawings(ticker: string): any[];
+	exportDrawings(ticker: string): string;
+	importDrawings(json: string): {
+		ticker: string;
+		drawings: any[];
+	} | null;
+	clearHistory(): void;
+}
+export interface ComparisonSymbol {
+	symbol: SymbolInfo;
+	data: KLineData[];
+	color: string;
+	visible: boolean;
+	normalizedData?: {
+		timestamp: number;
+		value: number;
+	}[];
+}
+/**
+ * Multi-symbol comparison overlay.
+ * Normalizes prices to percentage change from the first visible candle.
+ */
+export declare class ComparisonManager {
+	private _symbols;
+	private _widget;
+	private _datafeed;
+	private _colorIndex;
+	private _onChange?;
+	constructor(widget: Nullable<Chart>, datafeed: Nullable<Datafeed>);
+	setOnChange(callback: () => void): void;
+	getSymbols(): ComparisonSymbol[];
+	addSymbol(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<boolean>;
+	removeSymbol(ticker: string): void;
+	toggleVisibility(ticker: string): void;
+	private _normalizeData;
+	clear(): void;
+	destroy(): void;
+}
+/**
+ * Retry a function with exponential backoff
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: {
+	maxAttempts?: number;
+	baseDelay?: number;
+	maxDelay?: number;
+	onRetry?: (attempt: number, error: Error) => void;
+}): Promise<T>;
+/**
+ * Wrap a promise with a timeout
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, message?: string): Promise<T>;
+export type ErrorHandler = (error: Error) => void;
+/**
+ * Centralized error handler
+ */
+export declare class ErrorManager {
+	private _handlers;
+	private _lastError;
+	onError(handler: ErrorHandler): () => void;
+	report(error: Error): void;
+	getLastError(): Error | null;
+	clear(): void;
+}
+/**
+ * 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.
+ */
+/**
+ * Central registry for custom indicators and overlays.
+ * When users register custom tools via the public API,
+ * they are added here so the UI menus can dynamically display them.
+ */
+export interface CustomRegistryItem {
+	/** Internal name used by klinecharts engine */
+	name: string;
+	/** Display label shown in menus */
+	label: string;
+	/** Whether this is a main chart or sub chart indicator (indicators only) */
+	paneType?: "main" | "sub";
+}
+declare class Registry {
+	private _customIndicators;
+	private _customOverlays;
+	private _listeners;
+	/** Register a custom indicator for UI display */
+	addIndicator(item: CustomRegistryItem): void;
+	/** Register a custom overlay for UI display */
+	addOverlay(item: CustomRegistryItem): void;
+	/** Get all registered custom indicators */
+	getCustomIndicators(): CustomRegistryItem[];
+	/** Get custom indicators filtered by pane type */
+	getCustomMainIndicators(): CustomRegistryItem[];
+	getCustomSubIndicators(): CustomRegistryItem[];
+	/** Get all registered custom overlays */
+	getCustomOverlays(): CustomRegistryItem[];
+	/** Subscribe to changes (for reactive UI updates) */
+	onChange(listener: () => void): () => void;
+	private _notify;
+}
+/** Singleton registry instance */
+export declare const customRegistry: Registry;
+/**
+ * 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.
+ */
+export interface ShortcutBinding {
+	/** e.g. 'ctrl+z', 'alt+s', 'delete', 'escape', '1', 'f11' */
+	key: string;
+	description?: string;
+	callback: (e: KeyboardEvent) => void;
+}
+/**
+ * Keyboard shortcut manager for chart operations.
+ * Listens to keyboard events and dispatches registered callbacks.
+ */
+export declare class KeyboardShortcutManager {
+	private _container?;
+	private _bindings;
+	private _parsedBindings;
+	private _handler;
+	private _enabled;
+	constructor(_container?: HTMLElement | undefined);
+	/** Register a keyboard shortcut */
+	register(binding: ShortcutBinding): void;
+	/** Remove a keyboard shortcut */
+	remove(key: string): void;
+	/** Enable/disable all shortcuts */
+	setEnabled(enabled: boolean): void;
+	/** Get all registered bindings */
+	getBindings(): ShortcutBinding[];
+	/** Clean up */
+	destroy(): void;
+}
+export interface ChartTemplate {
+	name: string;
+	mainIndicators: string[];
+	subIndicators: string[];
+	styles?: any;
+	period?: {
+		multiplier: number;
+		timespan: string;
+		text: string;
+	};
+	theme?: string;
+	createdAt: number;
+}
+/**
+ * Chart template manager.
+ * Save/load indicator + style configurations as reusable presets.
+ */
+export declare class ChartTemplateManager {
+	private _store;
+	constructor(store: ChartStore);
+	/** Save a template */
+	saveTemplate(template: ChartTemplate): void;
+	/** Load a template by name */
+	loadTemplate(name: string): ChartTemplate | null;
+	/** Delete a template by name */
+	deleteTemplate(name: string): void;
+	/** Get all template names */
+	getTemplateNames(): string[];
+	/** Get all templates */
+	getTemplates(): ChartTemplate[];
+	private _getAll;
+	private _saveAll;
+}
+/**
+ * Crosshair sync manager.
+ * Links multiple Chart instances so that crosshair movement on one
+ * chart broadcasts the timestamp to all others.
+ */
+export declare class CrosshairSyncManager {
+	private _charts;
+	private _isSyncing;
+	/** Add a chart to the sync group */
+	addChart(chart: Chart): void;
+	/** Remove a chart from the sync group */
+	removeChart(chart: Chart): void;
+	/** Get number of linked charts */
+	getChartCount(): number;
+	/** Clean up all subscriptions */
+	destroy(): void;
+}
+export type ReplayStatus = "idle" | "playing" | "paused" | "ended";
+export type ReplayDataSource = "current" | "custom";
+export interface ReplayOptions {
+	/** Data source: 'current' = use loaded chart data, 'custom' = load from datafeed */
+	dataSource: ReplayDataSource;
+	/** Speed in ms per bar (default 500) */
+	speed?: number;
+	/** Start index (for 'current' source) or start timestamp (for 'custom' source) */
+	startFrom?: number;
+}
+export interface ReplayEventHandlers {
+	onStep?: (index: number, total: number, bar: KLineData) => void;
+	onPlay?: () => void;
+	onPause?: () => void;
+	onEnd?: () => void;
+	onStatusChange?: (status: ReplayStatus) => void;
+}
+/**
+ * Bar Replay Manager.
+ * Allows replaying historical data bar by bar for trading practice.
+ * Supports two data sources:
+ * - 'current': Uses already-loaded chart data
+ * - 'custom': Loads data from datafeed for a specific time range
+ */
+export declare class BarReplayManager {
+	private _chart;
+	private _datafeed;
+	private _fullData;
+	private _playbackIndex;
+	private _status;
+	private _speed;
+	private _timerId;
+	private _handlers;
+	private _originalData;
+	constructor(chart: Chart, datafeed?: Datafeed);
+	/** Set event handlers */
+	setHandlers(handlers: ReplayEventHandlers): void;
+	/** Start replay with the given options */
+	start(options: ReplayOptions): Promise<void>;
+	/** Load custom data from datafeed for replay */
+	loadData(symbol: SymbolInfo, period: Period, from: number, to: number): Promise<void>;
+	/** Play (auto-advance) */
+	play(): void;
+	/** Pause playback */
+	pause(): void;
+	/** Step one bar forward */
+	stepForward(): void;
+	/** Step one bar backward */
+	stepBackward(): void;
+	/** Jump to a specific index */
+	seekTo(index: number): void;
+	/** Set playback speed in ms per bar */
+	setSpeed(ms: number): void;
+	/** Get current state */
+	getStatus(): ReplayStatus;
+	getIndex(): number;
+	getTotal(): number;
+	getSpeed(): number;
+	getCurrentBar(): KLineData | null;
+	/** Stop replay and restore original data */
+	stop(): void;
+	/** Clean up */
+	destroy(): void;
+	private _applyData;
+	private _setStatus;
+}
+declare function load(key: string, ls: Record<string, string>): void;
+export interface RegisterOverlayOptions {
+	/** The klinecharts OverlayTemplate */
+	template: OverlayTemplate;
+	/** Display label in the drawing toolbar menu. Defaults to template.name */
+	label?: string;
+}
+export interface RegisterIndicatorOptions {
+	/** The klinecharts IndicatorTemplate */
+	template: IndicatorTemplate;
+	/** Display label in the indicator menu. Defaults to template.shortName or template.name */
+	label?: string;
+	/** Where the indicator appears: 'main' (candle pane) or 'sub' (new pane). Defaults to 'sub' */
+	paneType?: "main" | "sub";
+}
+/**
+ * Register a custom overlay (drawing tool).
+ * It will be registered with klinecharts AND automatically appear
+ * in the drawing toolbar menu under the "Custom" group.
+ *
+ * @example
+ * ```ts
+ * import { registerCustomOverlay } from '@anthropic/klinecharts-pro'
+ *
+ * // Simple: just pass an OverlayTemplate directly
+ * registerCustomOverlay({
+ *   name: 'myCustomTool',
+ *   totalStep: 3,
+ *   createPointFigures: ({ coordinates }) => {
+ *     return [{ type: 'line', attrs: { coordinates: [coordinates[0], coordinates[1]] } }]
+ *   }
+ * })
+ *
+ * // Advanced: pass options with custom label
+ * registerCustomOverlay({
+ *   template: { name: 'myTool', totalStep: 2, ... },
+ *   label: 'My Custom Tool'
+ * })
+ * ```
+ */
+export declare function registerCustomOverlay(templateOrOptions: OverlayTemplate | RegisterOverlayOptions): void;
+/**
+ * Register a custom technical indicator.
+ * It will be registered with klinecharts AND automatically appear
+ * in the indicator modal menu.
+ *
+ * @example
+ * ```ts
+ * import { registerCustomIndicator } from '@anthropic/klinecharts-pro'
+ *
+ * // Simple: just pass an IndicatorTemplate
+ * registerCustomIndicator({
+ *   name: 'MyRSI',
+ *   shortName: 'MRSI',
+ *   calcParams: [14],
+ *   figures: [{ key: 'rsi', title: 'RSI: ', type: 'line' }],
+ *   calc: (dataList, indicator) => {
+ *     // ... your calculation
+ *     return dataList.map(() => ({ rsi: 50 }))
+ *   }
+ * })
+ *
+ * // Advanced: with custom label and pane type
+ * registerCustomIndicator({
+ *   template: { name: 'VWAP', ... },
+ *   label: 'Volume Weighted Average Price',
+ *   paneType: 'main'  // appears on main candle chart
+ * })
+ * ```
+ */
+export declare function registerCustomIndicator(templateOrOptions: IndicatorTemplate | RegisterIndicatorOptions): void;
+export {
+	load as loadLocales,
+};
+export as namespace klinechartspro;
+export {};

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@simahfud/klinecharts-pro",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Professional TradingView-inspired charting component built on KLineChart. Features bar replay, keyboard shortcuts, 25 drawing tools, 6 chart types, and custom tool API.",
   "type": "module",
   "main": "./dist/klinecharts-pro.umd.js",