@coderyo/core 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,14 +1,35 @@
+import * as _coderyo_indicators from '@coderyo/indicators';
+import { IndicatorConfig, IndicatorLayerInfo, IndicatorLayerId } from '@coderyo/indicators';
+export { DEFAULT_INDICATOR_CONFIG, IndicatorConfig, IndicatorLayerId, IndicatorLayerInfo, IndicatorSource, clearedIndicatorConfig, disableIndicatorLayer, hasAnyActiveIndicators, hasMainChartOverlays, hasVisibleIndicatorPanes, indicatorConfigStorageKey, listActiveIndicatorLayers } from '@coderyo/indicators';
 import * as _coderyo_drawings from '@coderyo/drawings';
 import { DrawingRecord, DrawingStyleMeta } from '@coderyo/drawings';
 import * as _coderyo_data from '@coderyo/data';
 import { RealtimeStreamMode, Interval, DataProvider, SymbolResolver, Bar } from '@coderyo/data';
-import { IndicatorConfig } from '@coderyo/indicators';
 import { FetchPolicy } from '@coderyo/virtual-window';
-import { ChartVisibleRange } from '@coderyo/renderer-lite';
+import * as _coderyo_renderer_lite from '@coderyo/renderer-lite';
+import { ChartPaneId, ChartVisibleRange } from '@coderyo/renderer-lite';
 export { ChartVisibleRange } from '@coderyo/renderer-lite';
-import { BridgeAdapter, BridgeOutboundType } from '@coderyo/bridge';
+import { BridgeLayerPane, BridgeAdapter, BridgeOutboundType } from '@coderyo/bridge';
 export { PINE_EDITOR_DEFAULT, PINE_SAMPLE_SCRIPT, PineCompileResult, PineIrProgram, PinePlotSeries, compilePineLite, runPineLite } from '@coderyo/pine-lite';
 
+/** Layer fields used to map layout preset chart panes → renderer sync groups. */
+type LayerSyncInput = {
+    type: string;
+    pageId?: string;
+    syncTimeScaleGroupId?: string;
+};
+/** Per-pane patch: `string` = shared group; `null` = independent; `undefined` = pane absent on scope. */
+type PaneSyncGroupPatch = {
+    main?: string | null;
+    volume?: string | null;
+    indicator?: string | null;
+};
+/**
+ * Resolve pane sync group ids from layout layers.
+ * When `pageId` is set, only layers on that page are considered (multi-page presets).
+ */
+declare function resolvePaneSyncGroupsFromLayers(layers: LayerSyncInput[], pageId?: string): PaneSyncGroupPatch;
+
 interface ChartGapsFeatures {
     whitespace?: boolean;
     fillVisibleHoles?: boolean;
@@ -40,6 +61,13 @@ interface ChartFeatures {
     tickStream?: boolean;
     /** Run Pine-lite VM in a Web Worker when available (default true). */
     pineWorker?: boolean;
+    /**
+     * On interval/symbol reload, set bar spacing (px) for the interval (default true).
+     * Does not choose how many bars are visible — use history limit / setVisibleRange.
+     */
+    autoBarSpacingOnInterval?: boolean;
+    /** Override default bar spacing per interval (integrator). */
+    barSpacingByInterval?: Partial<Record<Interval, number>>;
 }
 interface ResolvedChartFeatures {
     fetchPolicy: FetchPolicy;
@@ -56,12 +84,24 @@ interface ResolvedChartFeatures {
     telemetry: boolean;
     tickStream: boolean;
     pineWorker: boolean;
+    autoBarSpacingOnInterval: boolean;
+    barSpacingByInterval?: Partial<Record<Interval, number>>;
 }
 declare const DEFAULT_CHART_FEATURES: ResolvedChartFeatures;
 declare function resolveChartFeatures(partial?: ChartFeatures): ResolvedChartFeatures;
 /** Empty chart until integrator calls setSymbol. */
 declare const PENDING_SYMBOL = "";
 
+/** Pluggable key-value storage for `indicatorPersist` (default: `localStorage`). */
+interface ChartStorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+declare function createLocalChartStorage(): ChartStorageAdapter;
+declare const defaultChartStorage: ChartStorageAdapter;
+declare function loadIndicatorConfig(storage: ChartStorageAdapter, symbol: string, interval: string): IndicatorConfig;
+declare function saveIndicatorConfig(storage: ChartStorageAdapter, symbol: string, interval: string, config: IndicatorConfig): void;
+
 interface ChartOptions {
     width?: number;
     height?: number;
@@ -72,6 +112,8 @@ interface ChartOptions {
     chartId?: string;
     /** Host element below main chart for MACD/RSI/KDJ panes (from ui-shell layout). */
     indicatorHost?: HTMLElement;
+    /** P2: separate volume pane mount (layer compositor). */
+    volumeMount?: HTMLElement;
     dataProvider: DataProvider;
     /** Integrator feature flags (minimal defaults). */
     features?: ChartFeatures;
@@ -86,6 +128,8 @@ interface ChartOptions {
     };
     /** @deprecated Use features.indicators */
     indicatorConfig?: IndicatorConfig;
+    /** Storage backend for `features.indicatorPersist` (default `localStorage`). */
+    chartStorage?: ChartStorageAdapter;
 }
 type ChartEvent = 'connectionChange' | 'barUpdate' | 'error' | 'visibleRangeChange' | 'symbolChange' | 'intervalChange' | 'crosshairChange' | 'destroyed' | 'drawingSelectionChange' | 'drawingContextMenu' | 'requestCursorTool' | 'featuresChange' | 'telemetry';
 type EventHandler = (payload?: unknown) => void;
@@ -93,7 +137,9 @@ declare class ChartController {
     private readonly container;
     private readonly options;
     private readonly store;
-    private readonly virtualWindow;
+    private fetchPolicy;
+    /** Per sync-group viewport for loadMore / render slicing (active bus drives IChart APIs). */
+    private readonly virtualWindows;
     private readonly orchestrator;
     private readonly handlers;
     private subscriptionId;
@@ -111,10 +157,15 @@ declare class ChartController {
     private catchUpInFlight;
     private lastCatchUpAt;
     private offPageResume;
+    /** After clearAllIndicators(); blocks Pine replot until script/features change. */
+    private pinePlotsSuppressed;
+    private readonly chartStorage;
+    private readonly onPaneResize;
     constructor(container: HTMLElement, options: ChartOptions);
     getFeatures(): ResolvedChartFeatures;
     setFeatures(patch: ChartFeatures): this;
     hasActiveSymbol(): boolean;
+    private activeVirtualWindow;
     private applyFeatures;
     private recompilePine;
     private applyPinePlots;
@@ -138,6 +189,10 @@ declare class ChartController {
         width?: number;
         height?: number;
     }): this;
+    /** P2: limit LWC resize to focused panes; also selects that pane's time-scale sync group for IChart APIs. */
+    setChartPaneResizeFocus(pane: ChartPaneId | 'all'): this;
+    /** Apply `syncTimeScaleGroupId` from layout layers to pane buses (empty = independent). */
+    applyTimeScaleSyncFromLayers(layers: LayerSyncInput[], pageId?: string): this;
     setDrawingTool(tool: _coderyo_drawings.DrawingTool): this;
     deleteSelectedDrawing(): boolean;
     copySelectedDrawing(): DrawingRecord | null;
@@ -145,6 +200,14 @@ declare class ChartController {
     updateSelectedDrawingStyle(patch: DrawingStyleMeta): void;
     deselectDrawing(): void;
     setIndicatorConfig(config: IndicatorConfig | null): void;
+    private applyPersistedIndicatorsOnInit;
+    private applyPersistedIndicatorsForContext;
+    /** @public List built-in indicator layers currently enabled on the chart. */
+    listIndicatorLayers(): IndicatorLayerInfo[];
+    /** @public Disable a single built-in indicator layer by id. */
+    disableIndicatorLayer(id: IndicatorLayerId): IndicatorConfig;
+    clearAllIndicators(): IndicatorConfig;
+    clearAllDrawings(): number;
     setReturnToCursorAfterDraw(v: boolean): void;
     setSymbol(symbol: string): Promise<void>;
     setInterval(interval: Interval): Promise<void>;
@@ -178,7 +241,76 @@ declare class ChartController {
     private emit;
 }
 
+/** Minimal chart surface for layer time-scale sync (matches `IChart.applyTimeScaleSyncFromLayers`). */
+interface LayerTimeScaleSyncChart {
+    applyTimeScaleSyncFromLayers(layers: Array<{
+        type: string;
+        pageId?: string;
+        syncTimeScaleGroupId?: string;
+    }>, pageId?: string): unknown;
+}
+type LayerBridgePane = BridgeLayerPane;
+interface LayerBridgePreset {
+    version?: number;
+    revision?: number;
+    pages: Array<{
+        id: string;
+        title?: string;
+    }>;
+    layers: Array<{
+        id: string;
+        pageId: string;
+        type: string;
+        syncTimeScaleGroupId?: string;
+        visible?: boolean;
+    }>;
+    groups: Array<{
+        id: string;
+        layerIds?: string[];
+        name?: string;
+    }>;
+    [key: string]: unknown;
+}
+/** Minimal LayerController surface for bridge wiring (avoids ui-shell in tests). */
+interface LayerBridgeController {
+    activePageId: string;
+    presetRevision: number;
+    getPreset(): LayerBridgePreset;
+    setLayerSyncGroup(layerId: string, groupId: string | null | undefined): boolean;
+    setLayerVisible(layerId: string, visible: boolean): void;
+    setActivePage(pageId: string): boolean;
+    setPreset(next: LayerBridgePreset): boolean;
+}
+interface ChartLayerBridgeRegistration {
+    chartId: string;
+    chart: LayerTimeScaleSyncChart;
+    layerController: LayerBridgeController;
+    compositorApply?: () => void;
+    syncCompositorShellVisibility?: () => void;
+    normalizePreset?: (input: LayerBridgePreset) => LayerBridgePreset;
+    mergePreset?: (current: LayerBridgePreset, partial: LayerBridgePreset) => LayerBridgePreset;
+}
+declare function registerChartLayerBridge(reg: ChartLayerBridgeRegistration): () => void;
+declare function unregisterChartLayerBridge(chartId: string): void;
+declare function clearLayerBridgeVisitedPages(chartId: string): void;
+declare function hasLayerBridgeRegistration(chartId?: string): boolean;
+declare function isValidLayerBridgePane(pane: unknown): pane is LayerBridgePane;
+/** Resolve chart pane → layer ids (`allPages` scans every page). */
+declare function resolvePaneLayerIds(preset: Pick<LayerBridgePreset, 'layers' | 'pages'>, pane: LayerBridgePane, opts?: {
+    allPages?: boolean;
+    activePageId?: string;
+}): string[];
+interface HandleLayerBridgeMessageOptions {
+    bridge: BridgeAdapter;
+    post: (type: string, payload: Record<string, unknown>) => void;
+}
+/** Handle a single inbound `host.layer.*` message; returns true if handled. */
+declare function handleLayerBridgeMessage(type: string, payload: Record<string, unknown>, opts: HandleLayerBridgeMessageOptions): boolean;
+/** Expose resolved sync groups for tests (same as chart `applyTimeScaleSyncFromLayers`). */
+declare function resolvePaneSyncGroupsForBridge(layers: LayerBridgePreset['layers'], pageId?: string): PaneSyncGroupPatch;
+
 declare const TRADVIEW_API_VERSION: 1;
+
 interface WireChartBridgeOptions {
     controller: ChartController;
     chart: IChart;
@@ -187,18 +319,21 @@ interface WireChartBridgeOptions {
     /** Allowlist of outbound bridge events; default all mapped events. */
     outboundEvents?: BridgeOutboundType[];
     crosshairThrottleMs?: number;
+    /** Schema 2 layer bridge (register via `registerChartLayerBridge` or pass here). */
+    layerBridge?: ChartLayerBridgeRegistration;
 }
+/** @public Wire host bridge messages to chart + controller events. */
 declare function wireChartBridge(opts: WireChartBridgeOptions): () => void;
 
 /** Synced by scripts/sync-versions.mjs from repo VERSION file */
-declare const TRADVIEW_VERSION: "1.0.2";
+declare const TRADVIEW_VERSION: "1.1.0";
 
 /** Playground / docs: opt-in full TV-like chart features. */
 declare function createDemoChartFeatures(opts: {
     indicatorConfig?: IndicatorConfig;
     returnToCursorAfterDraw?: boolean;
 }): ChartFeatures;
-declare function createDemoChartOptions(base: Pick<ChartOptions, 'dataProvider' | 'indicatorHost' | 'symbolResolver' | 'chartId'> & {
+declare function createDemoChartOptions(base: Pick<ChartOptions, 'dataProvider' | 'indicatorHost' | 'volumeMount' | 'symbolResolver' | 'chartId'> & {
     symbol: string;
     interval: Interval;
     theme?: 'dark' | 'light';
@@ -214,7 +349,10 @@ interface CreateChartOptions extends Omit<ChartOptions, 'dataProvider'> {
     /** If set, only these bridge outbound events are posted. */
     bridgeOutboundEvents?: BridgeOutboundType[];
     bridgeCrosshairThrottleMs?: number;
+    /** Schema 2: remote layer control (`host.layer.*`). */
+    layerBridge?: ChartLayerBridgeRegistration;
 }
+/** @public Chart instance API for integrators (apiVersion 1). */
 interface IChart {
     setSymbol(symbol: string): IChart;
     setInterval(interval: _coderyo_data.Interval): IChart;
@@ -238,6 +376,13 @@ interface IChart {
         width?: number;
         height?: number;
     }): IChart;
+    setChartPaneResizeFocus(pane: _coderyo_renderer_lite.ChartPaneId | 'all'): IChart;
+    /** Apply layout layer `syncTimeScaleGroupId` values to renderer pane buses. */
+    applyTimeScaleSyncFromLayers(layers: Array<{
+        type: string;
+        pageId?: string;
+        syncTimeScaleGroupId?: string;
+    }>, pageId?: string): IChart;
     setFullscreen(enabled: boolean): IChart;
     exportImage(opts?: {
         pixelRatio?: number;
@@ -252,6 +397,14 @@ interface IChart {
     updateSelectedDrawingStyle(patch: DrawingStyleMeta): void;
     deselectDrawing(): void;
     setIndicatorConfig(config: IndicatorConfig | null): void;
+    /** @public List enabled built-in indicator layers (MA, MACD, volume pane, etc.). */
+    listIndicatorLayers(): _coderyo_indicators.IndicatorLayerInfo[];
+    /** @public Disable one built-in indicator layer; returns applied config. */
+    disableIndicatorLayer(id: _coderyo_indicators.IndicatorLayerId): IndicatorConfig;
+    /** Hide all indicator panes and overlays; returns the applied config. */
+    clearAllIndicators(): IndicatorConfig;
+    /** Remove all drawings for the current symbol/interval; returns count removed. */
+    clearAllDrawings(): number;
     setReturnToCursorAfterDraw(v: boolean): void;
     setFeatures(patch: ChartFeatures): IChart;
     getFeatures(): ResolvedChartFeatures;
@@ -263,6 +416,10 @@ interface IChart {
     subscribeBars(handler: (bar: _coderyo_data.Bar) => void): () => void;
     destroy(): void;
 }
+/** @public Create a chart in the given container. */
 declare function createChart(target: HTMLElement | string, options: CreateChartOptions): IChart;
 
-export { ChartController, type ChartEvent, type ChartFeatures, type ChartOptions, type CreateChartOptions, DEFAULT_CHART_FEATURES, type IChart, PENDING_SYMBOL, type ResolvedChartFeatures, TRADVIEW_API_VERSION, TRADVIEW_VERSION, type WireChartBridgeOptions, createChart, createDemoChartFeatures, createDemoChartOptions, resolveChartFeatures, wireChartBridge };
+/** @public Upsert merge for Bridge `host.layer.setPreset` (`replace: false`). */
+declare function mergeLayerBridgePreset(current: LayerBridgePreset, partial: LayerBridgePreset): LayerBridgePreset;
+
+export { ChartController, type ChartEvent, type ChartFeatures, type ChartLayerBridgeRegistration, type ChartOptions, type ChartStorageAdapter, type CreateChartOptions, DEFAULT_CHART_FEATURES, type IChart, type LayerBridgeController, type LayerBridgePane, type LayerBridgePreset, type LayerSyncInput, type LayerTimeScaleSyncChart, PENDING_SYMBOL, type PaneSyncGroupPatch, type ResolvedChartFeatures, TRADVIEW_API_VERSION, TRADVIEW_VERSION, type WireChartBridgeOptions, clearLayerBridgeVisitedPages, createChart, createDemoChartFeatures, createDemoChartOptions, createLocalChartStorage, defaultChartStorage, handleLayerBridgeMessage, hasLayerBridgeRegistration, isValidLayerBridgePane, loadIndicatorConfig, mergeLayerBridgePreset, registerChartLayerBridge, resolveChartFeatures, resolvePaneLayerIds, resolvePaneSyncGroupsForBridge, resolvePaneSyncGroupsFromLayers, saveIndicatorConfig, unregisterChartLayerBridge, wireChartBridge };