@coderyo/renderer-lite 1.0.2 → 1.1.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Bar } from '@coderyo/data';
-import { IndicatorConfig } from '@coderyo/indicators';
 import { IChartApi, LineData, UTCTimestamp } from 'lightweight-charts';
+import { Interval, Bar } from '@coderyo/data';
+import { IndicatorConfig } from '@coderyo/indicators';
 
 interface ChartVisibleRange {
     fromMs: number;
@@ -21,6 +21,7 @@ declare class TimeScaleBus {
     visibleFromMs: number;
     visibleToMs: number;
     register(chart: IChartApi): void;
+    unregister(chart: IChartApi): void;
     subscribeTransform(listener: TransformListener): () => void;
     setBarsTimeRange(fromMs: number, toMs: number): void;
     getVisibleRange(): ChartVisibleRange | null;
@@ -32,6 +33,36 @@ declare class TimeScaleBus {
     private emit;
 }
 
+/** Trim; empty / whitespace → independent pane (no cross-pane sync). */
+declare function normalizeSyncGroupId(id?: string | null): string | null;
+type PaneSyncKey = 'main' | 'volume' | 'indicator';
+declare function independentBusKey(pane: PaneSyncKey): string;
+declare function resolveBusMapKey(groupId: string | null | undefined, pane: PaneSyncKey): string;
+interface PaneSyncGroupPatch {
+    main?: string | null;
+    volume?: string | null;
+    indicator?: string | null;
+}
+/**
+ * One {@link TimeScaleBus} per sync group id; empty group id → per-pane independent bus.
+ */
+declare class TimeScaleBusRegistry {
+    private readonly buses;
+    private readonly paneKeys;
+    private activeKey;
+    constructor();
+    getOrCreateBus(key: string): TimeScaleBus;
+    getBusKeyForPane(pane: PaneSyncKey): string;
+    getBusForPane(pane: PaneSyncKey): TimeScaleBus;
+    /** Active bus for IChart viewport APIs (follows last-focused chart pane). */
+    get activeBus(): TimeScaleBus;
+    getActiveBusKey(): string;
+    setActivePane(pane: PaneSyncKey): void;
+    setPaneSyncGroup(pane: PaneSyncKey, groupId: string | null | undefined): string;
+    forEachBus(fn: (key: string, bus: TimeScaleBus) => void): void;
+    moveChart(chart: IChartApi, fromKey: string, toKey: string, copyRange?: boolean): void;
+}
+
 type ScaleMode = 'linear' | 'log';
 interface CrosshairPayload {
     time: number;
@@ -49,8 +80,18 @@ interface PinePlotLine {
     color?: string;
     values: (number | null)[];
 }
+type ChartPaneId = 'main' | 'volume' | 'indicator';
+declare function isLayeredPaneMount(opts: Pick<PaneOrchestratorOptions, 'volumeMount'>): boolean;
+declare function shouldResizeChartPane(focus: Set<ChartPaneId> | null, pane: ChartPaneId): boolean;
 interface PaneOrchestratorOptions {
+    /** Main candlestick mount (required). */
     container: HTMLElement;
+    /**
+     * P2: separate volume layer host; when set, no flex column in container.
+     * Mount order: create empty `chartMain` + `chartVolume` nodes first, pass to compositor widgets,
+     * then `createChart(chartMain, { volumeMount: chartVolume })` so LWC mounts after layer frames apply.
+     */
+    volumeMount?: HTMLElement;
     indicatorRoot?: HTMLElement;
     theme?: 'dark' | 'light';
     scaleMode?: ScaleMode;
@@ -64,9 +105,26 @@ interface PaneOrchestratorOptions {
     /** Animate last candle + price line toward new OHLC (~150ms). */
     smoothPriceUpdate?: boolean;
     smoothPriceDurationMs?: number;
+    onIndicatorConfigChange?: (config: IndicatorConfig) => void;
+    /** When true (default), set bar spacing on interval reload — does not change visible bar count. */
+    autoBarSpacingOnInterval?: boolean;
+    barSpacingByInterval?: Partial<Record<Interval, number>>;
+    /**
+     * When false, do not listen for `tradview:pane-resize` (ChartController owns that path).
+     * @default true for standalone orchestrator use; ChartController passes false.
+     */
+    listenPaneResizeEvents?: boolean;
 }
 declare class PaneOrchestrator {
-    readonly bus: TimeScaleBus;
+    readonly busRegistry: TimeScaleBusRegistry;
+    /** Active sync group bus (last-focused pane); used by ChartController viewport APIs. */
+    get bus(): TimeScaleBus;
+    private readonly layeredPanes;
+    private readonly mainEl;
+    private readonly volWrap;
+    private detachMainVolResizer;
+    private resizeFocusPanes;
+    private readonly listenPaneResizeEvents;
     private readonly mainChart;
     private readonly volumeChart;
     private readonly mainSeries;
@@ -89,11 +147,19 @@ declare class PaneOrchestrator {
     private barTimesOrdered;
     private didInitialFit;
     private skipNextInitialFit;
+    /** setBars ran before the pane had layout size; refit on first real resize. */
+    private pendingViewportFit;
+    private pendingViewportBars;
     private indicatorConfig;
+    private onIndicatorConfigChange?;
+    private currentInterval;
+    private autoBarSpacingOnInterval;
+    private barSpacingByInterval?;
     private priceLine;
     private barAnimator;
     private smoothPriceDurationMs;
     constructor(opts: PaneOrchestratorOptions);
+    private readonly onPaneResize;
     setSmoothPriceUpdate(enabled: boolean, durationMs?: number): void;
     /** Update the last candle (and price line); optional smooth interpolation. */
     updateLastBar(target: Bar, opts?: {
@@ -102,16 +168,41 @@ declare class PaneOrchestrator {
     }): void;
     private applyLastBarToSeries;
     private ensurePriceLine;
+    setIntervalContext(interval: Interval): void;
     setTheme(theme: 'dark' | 'light'): void;
     setIndicatorConfig(config: IndicatorConfig | null): void;
+    private isVolumeVisible;
+    private closeVolumePane;
+    private applyVolumeVisibility;
+    /** Assign per-pane sync group ids (`''` / omit = independent). Re-registers LWC charts on group change. */
+    setPaneSyncGroups(patch: PaneSyncGroupPatch): void;
+    setActiveSyncPane(pane: ChartPaneId): void;
+    /** P2: when set, only these panes get LWC resize (panes in the same sync group still share TimeScaleBus). */
+    setResizeFocusPanes(panes: ChartPaneId[] | null): void;
+    /** Current resize focus (null = all panes). @internal — not part of public package API. */
+    getResizeFocusPanes(): ChartPaneId[] | null;
+    private shouldResizePane;
+    private rebuildMainVolumeResizer;
     setPinePlots(plots: PinePlotLine[] | null): void;
+    private teardownIndicatorStack;
     private applyMainOverlays;
     private syncPinePlotSeries;
     setShowGrid(show: boolean): void;
     setBars(bars: Bar[], gaps?: number[]): void;
+    private mainPaneHasSize;
+    private tryInitialViewportFit;
+    private flushPendingViewportFit;
     subscribeCrosshair(listener: (payload: CrosshairPayload | null) => void): () => void;
     private findNearestBar;
     private createIndicatorStack;
+    /** After symbol/interval reload: bar spacing for interval + show integrator-loaded span. */
+    applyIntervalBarSpacing(interval?: Interval): void;
+    setBarSpacingPolicy(opts: {
+        autoBarSpacingOnInterval?: boolean;
+        barSpacingByInterval?: Partial<Record<Interval, number>>;
+    }): void;
+    /** Sync time scale to loaded bars (integrator history); adjust bar spacing only, not bar count. */
+    private applyViewAfterDataReload;
     resetViewState(): void;
     /** Skip the next automatic fitContent after setBars (used by reloadHistory). */
     preserveViewportOnNextSetBars(): void;
@@ -126,6 +217,11 @@ declare class PaneOrchestrator {
     scrollToRealtime(): void;
     setLogScale(enabled: boolean): void;
     resize(): void;
+    /**
+     * Resize every LWC pane once for viewport fit; does **not** change {@link resizeFocusPanes}.
+     * @internal Used by ChartController data refresh paths.
+     */
+    resizeAllPanes(): void;
     getOverlayCanvas(): HTMLCanvasElement | null;
     timeToX(tMs: number): number | null;
     priceToY(price: number): number | null;
@@ -140,11 +236,21 @@ declare class PaneOrchestrator {
     private layoutForTheme;
 }
 
+declare function attachPaneResizer(topPane: HTMLElement, bottomPane: HTMLElement, opts?: {
+    minTopPx?: number;
+    minBottomPx?: number;
+    storageKey?: string;
+}): () => void;
+
+type IndicatorPaneId = 'macd' | 'rsi' | 'kdj';
 interface IndicatorPaneStackOptions {
     theme?: 'dark' | 'light';
     showGrid?: boolean;
     config?: IndicatorConfig;
+    onConfigChange?: (config: IndicatorConfig) => void;
 }
+/** PR-21: detect in-place tail updates vs full recompute. */
+declare function detectIndicatorBarMutation(prevTimes: number[], bars: Bar[]): 'full' | 'tail-append' | 'tail-update';
 declare class IndicatorPaneStack {
     private readonly root;
     private readonly macdChart;
@@ -163,10 +269,20 @@ declare class IndicatorPaneStack {
     private readonly macdWrap;
     private readonly rsiWrap;
     private readonly kdjWrap;
+    private readonly detachResizers;
+    private lastBarTimes;
+    private onConfigChange?;
     constructor(root: HTMLElement, bus: TimeScaleBus, opts?: IndicatorPaneStackOptions | 'dark' | 'light');
     setConfig(config: IndicatorConfig): void;
+    private closePane;
     private applyPaneVisibility;
+    /** Rebuild flex children and drag handles only between visible panes. */
+    private rebuildPaneLayout;
     clearBars(): void;
+    private warmupLookback;
+    private detectBarMutation;
+    private pushSeriesUpdates;
+    private pushHistUpdates;
     setBars(bars: Bar[]): void;
     setTheme(theme: 'dark' | 'light'): void;
     setShowGrid(show: boolean): void;
@@ -176,6 +292,8 @@ declare class IndicatorPaneStack {
     destroy(): void;
     private createPaneWrap;
     private layoutForTheme;
+    /** LWC instances for sync-group reassignment. */
+    getCharts(): IChartApi[];
 }
 declare function maOverlayLine(bars: Bar[], period?: number, source?: IndicatorConfig['source']): LineData<UTCTimestamp>[];
 declare function volMaOverlayLine(bars: Bar[], period?: number): LineData<UTCTimestamp>[];
@@ -186,4 +304,11 @@ declare function bollOverlayLines(bars: Bar[], period: number, mult: number, sou
     lower: LineData<UTCTimestamp>[];
 };
 
-export { type ChartVisibleRange, type CrosshairPayload, IndicatorPaneStack, type IndicatorPaneStackOptions, PaneOrchestrator, type PaneOrchestratorOptions, type PinePlotLine, type ScaleMode, TimeScaleBus, type TransformState, bollOverlayLines, emaOverlayLine, maOverlayLine, volMaOverlayLine };
+/**
+ * Default horizontal bar spacing (px) per interval so candle width feels consistent
+ * when the integrator controls how many bars are loaded / visible.
+ */
+declare function defaultBarSpacingForInterval(interval: Interval): number;
+declare function resolveBarSpacingForInterval(interval: Interval, overrides?: Partial<Record<Interval, number>>): number;
+
+export { type ChartPaneId, type ChartVisibleRange, type CrosshairPayload, type IndicatorPaneId, IndicatorPaneStack, type IndicatorPaneStackOptions, PaneOrchestrator, type PaneOrchestratorOptions, type PaneSyncGroupPatch, type PaneSyncKey, type PinePlotLine, type ScaleMode, TimeScaleBus, TimeScaleBusRegistry, type TransformState, attachPaneResizer, bollOverlayLines, defaultBarSpacingForInterval, detectIndicatorBarMutation, emaOverlayLine, independentBusKey, isLayeredPaneMount, maOverlayLine, normalizeSyncGroupId, resolveBarSpacingForInterval, resolveBusMapKey, shouldResizeChartPane, volMaOverlayLine };