@supersolutions/super-chart-web 0.0.0 → 0.1.0

package/dist/engine.d.ts

@@ -0,0 +1,147 @@
+import { CandleMode, ChartDataPort, Drawing, DrawingStore, DrawingType, EngineFrame, EngineIndicatorSpec, EngineIndicators, EngineInspection, EngineLayout, EngineRenderOptions, IndicatorDefinition, MarketBar, RealtimeView } from '@supersolutions/super-chart-core';
+
+/** Optional paint layer. Callbacks read borrowed data; they must not mutate chart state. */
+export interface EngineLayer {
+	update: (frame: EngineFrame, revealedRawBars: readonly MarketBar[]) => void;
+	paint: (context: CanvasRenderingContext2D) => void;
+	dispose?: () => void;
+}
+export interface EngineChartOptions {
+	count?: number;
+	/** Visible candle bounds for wheel, pinch, keyboard and programmatic navigation. */
+	viewport?: {
+		minBars?: number;
+		maxBars?: number;
+		rightPaddingBars?: number;
+		minCandleSpacing?: number;
+		maxCandleSpacing?: number;
+	};
+	/** Optional quality budget per Canvas layer; default uses the device pixel ratio. */
+	resolution?: {
+		maxPixelRatio?: number;
+		maxCanvasPixels?: number;
+	};
+	mode?: CandleMode;
+	layout?: EngineLayout;
+	render?: EngineRenderOptions;
+	indicators?: readonly EngineIndicatorSpec[];
+	inertia?: boolean;
+	onInspect?: (inspection: EngineInspection | null) => void;
+	onToolComplete?: () => void;
+}
+export interface EngineConfiguration {
+	render: EngineRenderOptions;
+	layout: EngineLayout;
+	indicators: readonly EngineIndicatorSpec[];
+	drawingsJson: string;
+	mode: CandleMode;
+}
+/** Owned Canvas renderer. The migration guide lists intentionally retired Pro APIs. */
+export declare class EngineChart {
+	private readonly series;
+	/** Loader boundary. Data reads return copies and are not used by the render hot path. */
+	readonly dataPort: ChartDataPort;
+	readonly view: RealtimeView;
+	readonly drawings: DrawingStore;
+	private readonly indicators;
+	private readonly doc;
+	private readonly win;
+	private readonly root;
+	private readonly canvas;
+	private readonly cursorCanvas;
+	private readonly drawingCanvas;
+	private readonly drawingContext;
+	private readonly drawingImages;
+	private readonly context;
+	private readonly cursorContext;
+	private readonly resizeObserver;
+	private readonly abort;
+	private readonly unsubscribers;
+	private readonly stopGestures;
+	private readonly drawingInput;
+	private readonly onInspect?;
+	private readonly inputs;
+	private readonly layers;
+	private readonly indicatorListeners;
+	private indicatorNoticeQueued;
+	private inputId;
+	private draining;
+	private preview;
+	private frame;
+	private frameId;
+	private cursorX;
+	private width;
+	private height;
+	private ratio;
+	private geometryDirty;
+	private paintDirty;
+	private drawingDirty;
+	private cursorDirty;
+	private disposed;
+	private readonly invalidateDrawings;
+	private readonly viewportOptions;
+	private readonly resolution;
+	private densityWidth;
+	private layout;
+	private renderOptions;
+	private dprQuery;
+	private readonly counters;
+	constructor(host: HTMLElement, options?: EngineChartOptions);
+	/** Millisecond OHLC input is normalized once at the data boundary. */
+	setData(bars: unknown, more?: boolean): void;
+	update(bar: unknown): void;
+	prependData(bars: unknown, more?: boolean): void;
+	updateBatch(bars: unknown, more?: boolean): void;
+	registerIndicator(definition: IndicatorDefinition): void;
+	unregisterIndicator(name: string, expectedCalculate?: IndicatorDefinition["calculate"]): boolean;
+	addIndicator(spec: EngineIndicatorSpec): string;
+	removeIndicator(id: string): boolean;
+	updateIndicator(id: string, changes: Pick<EngineIndicatorSpec, "params" | "pane" | "paneId" | "visible">): boolean;
+	listIndicators(): ReturnType<EngineIndicators["list"]>;
+	getRegisteredIndicatorNames(): readonly string[];
+	validateIndicatorReplacement(specs: readonly EngineIndicatorSpec[]): void;
+	replaceIndicators(specs: readonly EngineIndicatorSpec[]): void;
+	onIndicatorsChanged(listener: () => void): () => void;
+	private notifyIndicators;
+	setDrawingTool(tool: DrawingType | null): void;
+	/** Own this layer until removal or chart disposal. It receives only revealed replay data. */
+	addLayer(layer: EngineLayer): () => void;
+	setRenderOptions(options: EngineRenderOptions): void;
+	setLayout(options: EngineLayout): void;
+	getMetrics(): Readonly<typeof this.counters>;
+	/** Copy only the requested tail; the feed/render hot path keeps its owned array. */
+	getBars(options?: {
+		limit?: number;
+	}): MarketBar[];
+	getLastBar(): MarketBar | null;
+	getLayoutOptions(): EngineLayout;
+	getRenderOptions(): EngineRenderOptions;
+	/** Validate all supplied state before replacing any live configuration. */
+	restoreConfiguration(configuration: EngineConfiguration, data?: {
+		bars: readonly MarketBar[];
+		more?: boolean;
+	}): void;
+	/** Repaint owned layers after their model changes without rebuilding candle geometry. */
+	requestPaint(): void;
+	/** Decode local raster resources before an import commits retained drawings. */
+	prepareDrawingImages(drawings: readonly Drawing[]): Promise<void>;
+	/** Hold decoded resources across asynchronous market loading; release in finally. */
+	holdDrawingImages(drawings: readonly Drawing[]): () => void;
+	private retainDrawingImages;
+	snapshot(): Promise<Blob>;
+	dispose(): void;
+	private assertLive;
+	private updateReference;
+	private validateBars;
+	private validateRender;
+	private readonly pixelRatioChanged;
+	private watchPixelRatio;
+	private schedule;
+	private renderTick;
+	/** Keep an unused transparent layer tiny without changing its CSS or hit geometry. */
+	private sizeDrawingCanvas;
+	private flush;
+}
+export type { MarketBar, EngineRenderOptions, EngineLayout, EngineFrame, EngineInspection, Drawing, DrawingType, IndicatorDefinition } from "@supersolutions/super-chart-core";
+
+export {};

package/dist/engine.js

@@ -0,0 +1,6 @@
+import {
+  EngineChart
+} from "./chunk-PTYNDDEE.js";
+export {
+  EngineChart
+};

package/dist/index.d.ts

@@ -0,0 +1,413 @@
+import { CandleMode, ChartDataPort, DataStatus, Datafeed, Drawing, DrawingBounds, DrawingStore, DrawingType, EngineFrame, EngineIndicatorSpec, EngineIndicators, EngineInspection, EngineLayout, EngineRenderFrame, EngineRenderOptions, IndicatorDefinition, LoaderOptions, MarketBar, Period, RealtimeView, SymbolInfo, WorkspaceEvents, WorkspaceLoadResult, WorkspaceLoadState, WorkspaceMarket, WorkspaceReplayState, WorkspaceState } from '@supersolutions/super-chart-core';
+
+/** Optional paint layer. Callbacks read borrowed data; they must not mutate chart state. */
+export interface EngineLayer {
+	update: (frame: EngineFrame, revealedRawBars: readonly MarketBar[]) => void;
+	paint: (context: CanvasRenderingContext2D) => void;
+	dispose?: () => void;
+}
+export interface EngineChartOptions {
+	count?: number;
+	/** Visible candle bounds for wheel, pinch, keyboard and programmatic navigation. */
+	viewport?: {
+		minBars?: number;
+		maxBars?: number;
+		rightPaddingBars?: number;
+		minCandleSpacing?: number;
+		maxCandleSpacing?: number;
+	};
+	/** Optional quality budget per Canvas layer; default uses the device pixel ratio. */
+	resolution?: {
+		maxPixelRatio?: number;
+		maxCanvasPixels?: number;
+	};
+	mode?: CandleMode;
+	layout?: EngineLayout;
+	render?: EngineRenderOptions;
+	indicators?: readonly EngineIndicatorSpec[];
+	inertia?: boolean;
+	onInspect?: (inspection: EngineInspection | null) => void;
+	onToolComplete?: () => void;
+}
+export interface EngineConfiguration {
+	render: EngineRenderOptions;
+	layout: EngineLayout;
+	indicators: readonly EngineIndicatorSpec[];
+	drawingsJson: string;
+	mode: CandleMode;
+}
+/** Owned Canvas renderer. The migration guide lists intentionally retired Pro APIs. */
+export declare class EngineChart {
+	private readonly series;
+	/** Loader boundary. Data reads return copies and are not used by the render hot path. */
+	readonly dataPort: ChartDataPort;
+	readonly view: RealtimeView;
+	readonly drawings: DrawingStore;
+	private readonly indicators;
+	private readonly doc;
+	private readonly win;
+	private readonly root;
+	private readonly canvas;
+	private readonly cursorCanvas;
+	private readonly drawingCanvas;
+	private readonly drawingContext;
+	private readonly drawingImages;
+	private readonly context;
+	private readonly cursorContext;
+	private readonly resizeObserver;
+	private readonly abort;
+	private readonly unsubscribers;
+	private readonly stopGestures;
+	private readonly drawingInput;
+	private readonly onInspect?;
+	private readonly inputs;
+	private readonly layers;
+	private readonly indicatorListeners;
+	private indicatorNoticeQueued;
+	private inputId;
+	private draining;
+	private preview;
+	private frame;
+	private frameId;
+	private cursorX;
+	private width;
+	private height;
+	private ratio;
+	private geometryDirty;
+	private paintDirty;
+	private drawingDirty;
+	private cursorDirty;
+	private disposed;
+	private readonly invalidateDrawings;
+	private readonly viewportOptions;
+	private readonly resolution;
+	private densityWidth;
+	private layout;
+	private renderOptions;
+	private dprQuery;
+	private readonly counters;
+	constructor(host: HTMLElement, options?: EngineChartOptions);
+	/** Millisecond OHLC input is normalized once at the data boundary. */
+	setData(bars: unknown, more?: boolean): void;
+	update(bar: unknown): void;
+	prependData(bars: unknown, more?: boolean): void;
+	updateBatch(bars: unknown, more?: boolean): void;
+	registerIndicator(definition: IndicatorDefinition): void;
+	unregisterIndicator(name: string, expectedCalculate?: IndicatorDefinition["calculate"]): boolean;
+	addIndicator(spec: EngineIndicatorSpec): string;
+	removeIndicator(id: string): boolean;
+	updateIndicator(id: string, changes: Pick<EngineIndicatorSpec, "params" | "pane" | "paneId" | "visible">): boolean;
+	listIndicators(): ReturnType<EngineIndicators["list"]>;
+	getRegisteredIndicatorNames(): readonly string[];
+	validateIndicatorReplacement(specs: readonly EngineIndicatorSpec[]): void;
+	replaceIndicators(specs: readonly EngineIndicatorSpec[]): void;
+	onIndicatorsChanged(listener: () => void): () => void;
+	private notifyIndicators;
+	setDrawingTool(tool: DrawingType | null): void;
+	/** Own this layer until removal or chart disposal. It receives only revealed replay data. */
+	addLayer(layer: EngineLayer): () => void;
+	setRenderOptions(options: EngineRenderOptions): void;
+	setLayout(options: EngineLayout): void;
+	getMetrics(): Readonly<typeof this.counters>;
+	/** Copy only the requested tail; the feed/render hot path keeps its owned array. */
+	getBars(options?: {
+		limit?: number;
+	}): MarketBar[];
+	getLastBar(): MarketBar | null;
+	getLayoutOptions(): EngineLayout;
+	getRenderOptions(): EngineRenderOptions;
+	/** Validate all supplied state before replacing any live configuration. */
+	restoreConfiguration(configuration: EngineConfiguration, data?: {
+		bars: readonly MarketBar[];
+		more?: boolean;
+	}): void;
+	/** Repaint owned layers after their model changes without rebuilding candle geometry. */
+	requestPaint(): void;
+	/** Decode local raster resources before an import commits retained drawings. */
+	prepareDrawingImages(drawings: readonly Drawing[]): Promise<void>;
+	/** Hold decoded resources across asynchronous market loading; release in finally. */
+	holdDrawingImages(drawings: readonly Drawing[]): () => void;
+	private retainDrawingImages;
+	snapshot(): Promise<Blob>;
+	dispose(): void;
+	private assertLive;
+	private updateReference;
+	private validateBars;
+	private validateRender;
+	private readonly pixelRatioChanged;
+	private watchPixelRatio;
+	private schedule;
+	private renderTick;
+	/** Keep an unused transparent layer tiny without changing its CSS or hit geometry. */
+	private sizeDrawingCanvas;
+	private flush;
+}
+/**
+ * Draw in the frame's logical-pixel coordinate system. The host sets the DPR transform.
+ * No data or geometry is recalculated here; inspection and rendering use the same model.
+ * Separate indicator panes use the same model and painter without candle geometry.
+ */
+export declare function paintEngineFrame(ctx: CanvasRenderingContext2D, frame: EngineRenderFrame, options?: EngineRenderOptions): void;
+/** Draw on a separate cleared cursor layer so pointer moves do not redraw candles. */
+export declare function paintEngineCursor(ctx: CanvasRenderingContext2D, frame: EngineRenderFrame, x: number, options?: EngineRenderOptions): void;
+export type WorkspaceThemeName = "dark" | "light";
+export type WorkspaceChromeKey = "background" | "text" | "surface" | "border" | "divider" | "danger" | "toolbar" | "muted" | "hover" | "hoverBorder" | "focus" | "accent" | "active" | "panelBorder" | "panel" | "panelShadow" | "error" | "colorScheme";
+/** The existing scoped workspace variables; host styles and `ui.variables` use these same names. */
+export declare const WORKSPACE_CHROME_VARS: Readonly<Record<WorkspaceChromeKey, string>>;
+export interface WorkspaceTheme {
+	/** Values for `WORKSPACE_CHROME_VARS`. */
+	readonly chrome: Readonly<Record<WorkspaceChromeKey, string>>;
+	/** Canvas colours are explicit renderer values, independent of the DOM variables. */
+	readonly render: Readonly<Required<Pick<EngineRenderOptions, "background" | "grid" | "text" | "up" | "down" | "line">>>;
+}
+/** Dark keeps the current workspace defaults; light also covers controls, menus and status surfaces. */
+export declare const WORKSPACE_THEMES: Readonly<Record<WorkspaceThemeName, WorkspaceTheme>>;
+/** Host-owned persistence: writes are synchronous acknowledgements, not fire-and-forget. */
+export interface WorkspaceDrawingStorage {
+	getItem: (key: string) => string | null;
+	setItem: (key: string, value: string) => void;
+}
+export interface WorkspaceDrawingCacheOptions {
+	/** Namespace is explicit; nothing is written to browser storage by default. */
+	namespace: string;
+	storage: WorkspaceDrawingStorage;
+	maxSymbols?: number;
+	/** Approximate UTF-16 string bytes in the in-memory document cache. */
+	maxBytes?: number;
+}
+export interface WorkspaceSearchOptions {
+	/** In-memory recents by default. Set zero to disable; at most 50. */
+	recentLimit?: number;
+	initialRecent?: readonly SymbolInfo[];
+	/** Explicit host namespace enables persistence; no default global storage key. */
+	persistKey?: string;
+	storage?: Pick<Storage, "getItem" | "setItem">;
+}
+/** Scoped workspace chrome. Canvas colours remain in chart.render. */
+export interface WorkspaceAppearanceOptions {
+	/** Additional root classes for host styles; .sc-workspace always remains. */
+	className?: string;
+	density?: "compact" | "comfortable";
+	/** CSS custom properties only; values inherit from the host when omitted. */
+	variables?: Readonly<Partial<Record<`--sc-${string}`, string>>>;
+}
+export interface ChartWorkspaceOptions {
+	datafeed: Datafeed;
+	symbol: SymbolInfo;
+	period: Period;
+	periods?: readonly Period[];
+	chart?: EngineChartOptions;
+	/**
+	 * `light` or `dark` for the chrome and the canvas colours; `chart.render` colours still win. Leave it out to keep the
+	 * dark default and restyle through the existing `--sc-*` CSS custom properties (see `WORKSPACE_CHROME_VARS`).
+	 */
+	theme?: WorkspaceThemeName;
+	loader?: Omit<LoaderOptions, "datafeed" | "env">;
+	search?: WorkspaceSearchOptions;
+	ui?: WorkspaceAppearanceOptions;
+	/** Host persistence for completed edits; only acknowledged documents are evicted from memory. */
+	drawingCache?: WorkspaceDrawingCacheOptions;
+	/** Period-close estimate. Disable or supply the exchange's real session close. */
+	countdown?: {
+		enabled?: boolean;
+		closeTimestamp?: (market: WorkspaceMarket, lastBar: MarketBar) => number | null;
+	};
+}
+/** DOM controls for the owned engine. This is not the legacy Pro API compatibility surface. */
+export declare class ChartWorkspace {
+	readonly chart: EngineChart;
+	/** Constructor load outcome; same-tick market changes share its final request. */
+	readonly ready: Promise<WorkspaceLoadResult>;
+	private readonly doc;
+	private readonly win;
+	private readonly abort;
+	private loader;
+	private timedReplay;
+	private readonly countdown;
+	private readonly loaderOptions;
+	private readonly loads;
+	private readonly events;
+	private readonly loaderUnsubscribe;
+	private readonly datafeed;
+	private readonly root;
+	private readonly chartHost;
+	private readonly statusNode;
+	private readonly stageStatus;
+	private readonly replayControls;
+	private readonly downloadButton;
+	private downloading;
+	private reportedStatusUI;
+	private readonly notice;
+	private readonly symbolButton;
+	private readonly periodSelect;
+	private readonly drawingSelect;
+	private readonly indicatorSelect;
+	private readonly syncPresentation;
+	private readonly searchPanel;
+	private readonly searchInput;
+	private readonly searchResults;
+	private readonly searchStatus;
+	private readonly recents;
+	private readonly recentLimit;
+	private searchSymbols;
+	private searchActive;
+	private searchShownQuery;
+	private searchLoading;
+	private readonly retryButton;
+	private readonly olderButton;
+	private readonly replayInfo;
+	private readonly replayButtons;
+	private readonly replaySpeed;
+	private readonly drawingButtons;
+	private readonly unsubscribe;
+	private readonly drawingDocuments;
+	private drawingSaveTimer;
+	private readonly persistentDrawings;
+	private lastDrawingList;
+	private readonly downloads;
+	private readonly actions;
+	private symbol;
+	private period;
+	private periods;
+	private scale;
+	private drawingSymbol;
+	private displayedPair;
+	private pending;
+	private waitingStart;
+	private olderPending;
+	private applyError;
+	private cancelled;
+	private reportedLoadState;
+	private reportedReplayState;
+	private searchAbort;
+	private searchTimer;
+	private searchGeneration;
+	private disposed;
+	private restoreGeneration;
+	private pendingRestore;
+	constructor(host: HTMLElement, options: ChartWorkspaceOptions);
+	getSymbol(): SymbolInfo;
+	getPeriod(): Period;
+	/** Register an optional pack on demand without loading it into every workspace. */
+	registerIndicator(definition: IndicatorDefinition): void;
+	setSymbol(symbol: SymbolInfo): Promise<WorkspaceLoadResult>;
+	setPeriod(period: Period | string): Promise<WorkspaceLoadResult>;
+	/** Validate both inputs before changing either; same-tick calls fetch the final pair once. */
+	setMarket(symbol: SymbolInfo, period: Period | string): Promise<WorkspaceLoadResult>;
+	private changeMarket;
+	/** Starts a real fresh request even when the selected market is unchanged. */
+	reload(): Promise<WorkspaceLoadResult>;
+	/**
+	 * Abort the pending market load and its history/sync requests. Explicit
+	 * cancellation retires this loader's cache; the next reload starts fresh.
+	 * A settled chart is unaffected (returns false).
+	 */
+	cancelLoad(): boolean;
+	on<K extends keyof WorkspaceEvents>(type: K, listener: (event: WorkspaceEvents[K]) => void): () => void;
+	off<K extends keyof WorkspaceEvents>(type: K, listener: (event: WorkspaceEvents[K]) => void): void;
+	/** Detached candle objects; during replay, only revealed candles are returned. */
+	getBars(options?: {
+		limit?: number;
+	}): MarketBar[];
+	getLoadState(): WorkspaceLoadState;
+	getState(): WorkspaceState;
+	getReplayState(): WorkspaceReplayState;
+	startReplay(at?: number): boolean;
+	stepReplay(delta?: number): WorkspaceReplayState;
+	startReplayAt(timestamp: number): boolean;
+	playReplay(speed?: number): boolean;
+	pauseReplay(): void;
+	setReplaySpeed(speed: number): void;
+	exitReplay(): WorkspaceReplayState;
+	/** Market, indicators, drawings and presentation only; no feed, code or credentials. */
+	exportDocument(): string;
+	/**
+	 * Validate/decode first, then load the requested market through the usual feed.
+	 * A failed or superseded load never applies saved state to a different market.
+	 * Registered executable layers are host-owned and are not serialized/restored.
+	 */
+	restoreDocument(json: string): Promise<WorkspaceLoadResult>;
+	getStatus(): DataStatus;
+	/**
+	 * Switch the chrome and the canvas colours to a preset. The preset's six canvas colours replace the current ones,
+	 * including any the host passed in `chart.render`; set those again afterwards through `chart.setRenderOptions`.
+	 * Preset chrome variables likewise replace earlier values; other `ui.variables` stay untouched.
+	 */
+	setTheme(theme: WorkspaceThemeName): void;
+	private applyChromeTheme;
+	dispose(): void;
+	/** Flush a completed edit before leaving. Storage errors propagate; the document
+	 * stays in memory and disposal can be retried after the host handles the error. */
+	saveDrawings(): void;
+	getDrawingCacheStats(): {
+		symbols: number;
+		bytes: number;
+		unsaved: number;
+	};
+	private queueDrawingSave;
+	private market;
+	private requestedPair;
+	private resolvePeriod;
+	private createReplay;
+	private createLoader;
+	private shownMatches;
+	private prepareRequest;
+	private request;
+	private currentResult;
+	private settleLoad;
+	private dataPort;
+	private restoreDrawings;
+	private updateStatus;
+	private updateReplay;
+	private updateDrawingControls;
+	private openSearch;
+	private closeSearch;
+	private cancelSearch;
+	private queueSearch;
+	private search;
+	private chooseSearchResult;
+	private searchKey;
+	private download;
+	private node;
+	private listen;
+	private button;
+	private select;
+	private row;
+	private field;
+	private setText;
+	private menu;
+	private run;
+	private errorMessage;
+	private showNotice;
+	private assertLive;
+}
+/** Encode a local file. Decode with DrawingImageRenderer.prepare before committing it. */
+export declare function createDrawingImage(blob: Blob, signal?: AbortSignal): Promise<string>;
+/** One instance per chart. All pixels originate in local raster bytes, keeping export untainted. */
+export declare class DrawingImageRenderer {
+	private readonly decode;
+	private readonly entries;
+	private readonly held;
+	private pixels;
+	private disposed;
+	/** Optional owner-window decoder is useful when the chart lives in another document. */
+	constructor(decode?: (blob: Blob) => Promise<ImageBitmap>);
+	prepare(source: string): Promise<void>;
+	getError(source: string): Error | null;
+	paint(context: CanvasRenderingContext2D, source: string, bounds: DrawingBounds, clip: DrawingBounds, onInvalidate?: () => void): "ready" | "loading" | "unavailable";
+	/** Source data stays in drawing history; a released bitmap can be decoded again on undo. */
+	retain(sources: ReadonlySet<string>): void;
+	/** Keep validated resources across an asynchronous market/document restore. */
+	hold(sources: ReadonlySet<string>): () => void;
+	has(source: string): boolean;
+	release(source: string): void;
+	dispose(): void;
+}
+export { ENGINE_CHART_TYPES, EngineIndicators, DrawingStore, projectDrawing, hitTestDrawingGeometry, DRAWING_TYPES, drawingAnchorCount, createPriceScale, buildEngineFrame, parseWorkspaceDocument, WORKSPACE_DOCUMENT_LIMITS, validateDrawingImage, DRAWING_IMAGE_LIMITS } from "@supersolutions/super-chart-core";
+export type { EngineRenderOptions, EngineChartType, EngineIndicatorSpec, EngineIndicatorInstance, EngineIndicatorResult, IndicatorDefinition, IndicatorFigure, IndicatorRow, IndicatorPane, Drawing, DrawingType, DrawingAnchor, DrawingGeometry, DrawingContext, PriceScaleOptions, PriceScaleMode, EngineFrame, EngineLayout, EngineInspection, WorkspaceDocumentV1, WorkspaceDocumentOptions, WorkspaceSavedRender, Datafeed, SymbolInfo, Period, Timespan, HistoryRequest, HistoryResult, SearchRequest, DatafeedSubscribeCallback, MarketBar, WorkspaceState, WorkspaceEvents, WorkspaceLoadState, WorkspaceLoadResult, WorkspaceMarket, WorkspaceReplayState } from "@supersolutions/super-chart-core";
+
+export {
+	ChartWorkspace as SuperChart,
+};
+
+export {};