@tradecanvas/chart 1.72.0 → 1.72.2

package/dist/widget/ChartWidget.d.ts

@@ -11,20 +11,45 @@ import { CompareWay } from './widgetCompare.js';
 import { Translator } from './i18n.js';
 import { WidgetFeature, WidgetFeatures } from './widgetFeatures.js';
 export declare class ChartWidget {
+    /** The intervals the widget offers: the menu, the ones pinned, typed ones and the range bar's. */
+    private readonly intervals;
+    /** Editing a drawing: its toolbar, its words typed in place, its settings and its templates. */
+    private readonly drawingEdit;
+    /** The chart settings: their state, where they are kept, the dialog's edit, and the scale they show. */
+    private readonly chartSettings;
+    /** The dock by the chart: its panels, its rail and how wide it is. */
+    private readonly docking;
+    /** Saved layouts and shared views: what a layout holds, where it is kept, and the link to a view. */
+    private readonly layouts;
+    /** The command palette's entries and the actions they run. */
+    private readonly commands;
+    /** The legend over the chart: the symbol's row and the indicators' rows, and their menu. */
+    private readonly legend;
+    /** The chart's context menus: on the chart, on a drawing, and the clear menu. */
+    private readonly menus;
+    /** Trading by the chart: the account panel, the order ticket, the depth ladder and the bracket bar. */
+    private readonly trading;
+    /** Price alerts: their panel, what they are checked against, and the notices when one fires. */
+    private readonly alerting;
+    /** The watchlists by the chart: their symbols, lists and quotes. */
+    private readonly watching;
+    /** Other symbols compared with the chart's: their bars, the compare dialog, the scale they hold. */
+    private readonly comparing;
     private chart;
     private state;
     /** The theme for each mode: the host's own where it gave one, so the toggle brings it back. */
     private themeOf;
     private toolbar;
+    /** What is open, by its toolbar button's role (`'alerts'`, `'account'`, `'indicators'`…): one effect shows it on the toolbar. */
+    private readonly openRoles;
     private sidebar;
     private settingsPart;
     private get settings();
     private statusBar;
     private goToDatePart;
     private get goToDate();
-    private readonly tooltip;
+    private tooltip;
     private indicatorLegend;
-    private legendFrame;
     /**
      * Modals (settings, search, command palette, hotkeys) mount here: it carries
      * the theme tokens to `document.body`, and moves inside the widget while
@@ -40,45 +65,25 @@ export declare class ChartWidget {
     /** Stops following presses for the page's shortcuts (see keyTarget). */
     private unregisterKeys;
     private readonly onFullscreenChange;
-    private commandPalette;
-    private symbolSearch;
-    /** The panels by the chart (watchlist, alerts, objects, data window, symbol info) and their rail. */
-    private dock;
-    /** Whether the widget was narrow when the dock last looked (null: not yet). */
-    private dockNarrow;
-    /** Follows the widget's width for the dock. */
-    private dockObserver;
+    private commandPalettePart;
+    private get commandPalette();
+    private symbolSearchPart;
+    private get symbolSearch();
+    /** Letters typed on the chart while the symbol search's code loads: it opens with all of them. */
+    private typedWhileLoading;
     private hotkeySheetPart;
     private get hotkeySheet();
-    private replayBar;
+    /** Bar replay: its panel over the chart and the session it drives. Made in the constructor, once the chart is up. */
+    private replay;
     private dragDrop;
-    private alertsPanel;
     private objectTree;
     private indicatorSettingsPart;
     private get indicatorSettings();
-    private indicatorPicker;
+    private indicatorPickerPart;
+    private get indicatorPicker();
     private drawingStyle;
     private drawingSettingsPart;
     private get drawingSettings();
-    private drawingMenu;
-    /** A text drawn just now whose words the settings ask for: Cancel there takes it back. */
-    private justDrawnText;
-    /** A text drawing's words typed in place over it. */
-    private inlineText;
-    /** The drawing whose words are being typed in place, and whether it was just drawn. */
-    private inlineTextId;
-    private inlineTextNew;
-    /** The chart's type sizes the look last wrote: a host's own change since makes them the new base. */
-    private chartFontWritten;
-    /** Stops waiting to ask for a just-drawn text's words (the widget goes, or another text is drawn first). */
-    private cancelTextPrompt;
-    /** The trash button's menu, made the first time it opens. */
-    private clearMenu;
-    private selectionToolbar;
-    private selectionToolbarFrame;
-    private chartMenu;
-    /** The pane a chart menu was opened on (its scale switches act on it). */
-    private menuPane;
     /** Whether the chart menu offers a download of the data. */
     private canExport;
     /** The latest fetch of each symbol the chart's indicators read. */
@@ -92,32 +97,10 @@ export declare class ChartWidget {
     /** The chart's type sizes before the look scaled them. */
     private chartFontBase;
     private scaleObserver;
-    /** The legend row's "more" menu: move the indicator to another pane. */
-    private legendMenu;
     private templates;
     private templatePrompt;
-    /** The chart templates of the settings' Template menu, and the prompt that names a new one. */
-    private chartTemplates;
-    private chartTemplatePrompt;
-    /** Asks a drawing template's name, over the drawing's settings. */
-    private drawingTemplatePrompt;
-    /**
-     * The settings open now: as they were on opening, and the keys changed since
-     * (a change, a reset, a template). Cancel puts those back, OK records them
-     * as one step; the rest (an axis dragged meanwhile) is left as it is.
-     */
-    private settingsEdit;
-    private intervalInput;
     /** The note shown over a signal marker under the pointer. */
     private markerTip;
-    private accountPanel;
-    private orderTicket;
-    private accountFrame;
-    private layoutSession;
-    private layoutsUI;
-    private bracketBar;
-    private alertNotifier;
-    private depthLadder;
     private dataWindow;
     private lastHoverIndex;
     /** The bar the crosshair reported at it: on Renko and the like a brick, not a data bar. */
@@ -138,21 +121,7 @@ export declare class ChartWidget {
     private customTimeframes;
     /** Timeframes on offer, shortest first. */
     private timeframes;
-    private watchlist;
-    private watchlistSparkBuffer;
     private sessionRefPrice;
-    /** Per-symbol refPrice explicitly pushed by the host via `setWatchlistEntry` — takes precedence over `sessionRefPrice`. */
-    private hostWatchlistRefPrice;
-    private watchlistInterval;
-    private watchlistStore;
-    /** The list follows `setSymbols` (no lists given, none kept). */
-    private watchlistFromSymbols;
-    private quoteSource;
-    private stopQuotes;
-    /** The symbols quotes are coming for, joined. */
-    private quotedKey;
-    /** The latest quote of each symbol. */
-    private quotes;
     private symbolInfoPanel;
     /** Headlines per symbol, kept a few minutes; a late answer for an earlier symbol is dropped. */
     private news;
@@ -162,29 +131,6 @@ export declare class ChartWidget {
     private chartNav;
     /** Bars on screen, for the navigation's scroll step. */
     private visibleBarCount;
-    private replayPollInterval;
-    /** The replay's speed, a multiplier: 1 plays one bar of the chart a second. */
-    private replaySpeed;
-    /** The chart's bars the replay goes through, and when the step shown opened (from `replayStep`). */
-    private replayBarsTotal;
-    private replayStepTime;
-    /** The symbol and interval of the finer steps given to the replay running (null: none given). */
-    private replayStepsKey;
-    /** `'auto'`, `'bar'`, or the finer interval a replay steps through. */
-    private replayStep;
-    private replayStartSeq;
-    /** The time of a bar picked while the next bars loaded: the replay starts there once they come. */
-    private replayPickTime;
-    /** A replay start waiting for its finer steps: a Play pressed meanwhile plays it once it starts. */
-    private replayStartPending;
-    private replayPlayWanted;
-    /** Finer bars fetched or built for the last replay in steps. */
-    private replayStepsCache;
-    /** While picking the start bar: shades the bars right of the pointer. */
-    private replayShade;
-    private layoutKeyPrefix;
-    private layoutDebounceMs;
-    private activeLayoutKey;
     private root;
     private chartContainer;
     private loading;
@@ -219,26 +165,6 @@ export declare class ChartWidget {
      * told of the new one; anything told since is the new one's.
      */
     private chartInfoAtSwitch;
-    private settingsState;
-    /** What Reset in the settings panel goes back to: the defaults, as the host's features set them. */
-    private settingsDefaults;
-    /** Where `persistSettings` keeps the settings; null while it is off. */
-    private settingsStore;
-    /**
-     * The settings as last kept and told to the listeners, as JSON: a change
-     * that leaves them so (a Cancel, a call setting what is already set) is
-     * neither. Null while the widget is being made, which tells nobody.
-     */
-    private settingsPublished;
-    /**
-     * The settings shared links set this visit (`shown`) and the viewer's own
-     * they took the place of (`own`): what `persistSettings` keeps for a
-     * setting still as a link set it. Null when no link set any.
-     */
-    private linkSettings;
-    private readonly settingsListeners;
-    /** Switches the host's features turned off: a setting kept, shared or in a layout can't turn them on. */
-    private settingsLocked;
     private t;
     private adapter;
     private boundGlobalKeydown;
@@ -248,28 +174,6 @@ export declare class ChartWidget {
     private builtInZone;
     /** The timeframe the user (or the host) picked: ranges never show finer than it, layouts keep it. */
     private chosenTimeframe;
-    /** Counts range clicks and the user's own picks: a range waiting behind a newer one gives way. */
-    private rangeSeq;
-    /** Ranges apply one at a time, each reading the bars the last one brought. */
-    private rangeQueue;
-    private compares;
-    /** How the compare dialog adds a symbol: the way picked last. */
-    private compareWay;
-    /** Symbols whose bars are on the way to be compared in percent. */
-    private readonly comparesLoading;
-    /**
-     * Set by the first percent compare, cleared when the last one goes or the
-     * user picks a scale meanwhile: while set, a regular price scale reads in
-     * percent, as the compare lines do (`effectiveScaleMode`). Never saved.
-     */
-    private compareScaleHeld;
-    /** The latest round of percent compare fetches: an older round's answers are dropped. */
-    private compareFetchSeq;
-    /** The percent compares' older stretches are on their way; `compareOlderAgain`: more pages came meanwhile. */
-    private compareOlderBusy;
-    private compareOlderAgain;
-    /** Older bars asked no stretch of a compare whose bars were still at another interval: a round once they come. */
-    private compareOlderPassed;
     /** Every switch, on or off (see `setFeatures`). */
     private featureState;
     /** The host's own shortcuts, first added first. */
@@ -281,13 +185,41 @@ export declare class ChartWidget {
     /** Whether the chart shows the "+" by the price axis while its switch is on. */
     private priceAxisAddDefault;
     constructor(container: HTMLElement, givenOptions?: ChartWidgetOptions);
+    /** The options read once: the symbols, the settings they seed, the theme, the chart's features, the intervals and the starting state. */
+    private readOptions;
+    /** The widget's root and portal, its direction and theme, and the look's tokens on both. */
+    private buildRoot;
+    /** The toolbar along the top. */
+    private buildToolbar;
+    /** The row under the toolbar: the drawing tools, the chart's box, the dock and the watchlist; and the account panel's place under it. */
+    private buildBody;
+    /** The chart, and what follows its bars, its market and the page. */
+    private buildChart;
+    /** The status bar along the bottom. */
+    private buildStatusBar;
+    /** The settings, the symbol search and the shortcut sheet, each made when first opened. */
+    private buildDialogs;
+    /** The bars, the legend, compares, replay and the data window follow the chart's events. */
+    private followChart;
+    /** Drawing styles, templates, defaults and the text typed in place. */
+    private wireDrawingEditing;
+    /** The drawing's and the chart's menus, its toolbar when selected, undo and redo, and typing an interval. */
+    private wireChartMenus;
+    /** Named layouts, the account panel, the order ticket and bracket orders. */
+    private buildTrading;
+    /** Price alerts, and the indicators dialog. */
+    private buildAlerts;
+    /** The object tree, and every panel into the dock. */
+    private buildPanels;
+    /** The command palette, fullscreen and the keys. */
+    private buildCommandPalette;
+    /** The kept settings, the stream, the watchlist's ticks, the first update and onReady. */
+    private finishSetup;
     /**
      * The dialogs' code, loaded once the page has a moment to spare: not in the way of the chart
      * coming up, and in before the user opens one, so the first opens at once too.
      */
     private preloadDialogsWhenIdle;
-    /** A view shared in the URL (`#tcw=`), when `shareUrl` is on. */
-    private restoreSharedView;
     /**
      * Replace the symbols on offer, tickers or SymbolInfo as in the `symbols`
      * option. Does not change the active symbol. A watchlist made from
@@ -333,8 +265,6 @@ export declare class ChartWidget {
      * depth ladder (the `depthLadder` option), or its switch off.
      */
     openPanel(panel: WidgetPanel): boolean;
-    /** Whether the widget has `panel`: the watchlist and the ladder only when made with them, every one with its switch on. */
-    private hasPanel;
     /** Shut the dock. */
     closePanel(): void;
     /** The panel open in the dock, or null. */
@@ -351,10 +281,6 @@ export declare class ChartWidget {
     private intlLocale;
     /** The language words in the panels are written in ("in 3 hours", weekday names): the widget's. */
     private textLocale;
-    private createWatchlist;
-    /** Quotes for the shown list's symbols: a new subscription when they change. */
-    private followQuotes;
-    private takeQuotes;
     setSymbol(symbol: string): Promise<void>;
     /**
      * Push an entry into the watchlist (e.g., from your own WebSocket).
@@ -366,7 +292,6 @@ export declare class ChartWidget {
      * auto-tick loop stops clobbering it (see `tickWatchlist`).
      */
     setWatchlistEntry(symbol: string, entry: Partial<WatchlistEntry>): void;
-    private tickWatchlist;
     /** Ignored when the chart's `features.timeframes` whitelist leaves `tf` out. */
     setTimeframe(tf: TimeFrame): Promise<void>;
     /**
@@ -423,68 +348,17 @@ export declare class ChartWidget {
     private handleSymbolClick;
     /** The symbol search, started from `query` (a letter typed on the chart). */
     private openSymbolSearch;
+    /** The symbol search for another job (a symbol to add to a list, one to compare with), once its code is in. */
+    private withSymbolSearch;
     /** The host's symbol search, else the adapter's; none filters `symbols`. */
     private symbolSearchFn;
     private handleTimeframe;
-    /**
-     * A range from the range bar. A long one switches to the timeframe whose
-     * bars it fits (five years of days in weeks, decades in months), a short
-     * one back toward the user's own (`timeframeForRange`); then the range is
-     * shown. Off with `features: { 'statusBar.rangeTimeframe': false }`.
-     */
-    private applyRangePreset;
-    private runRangePreset;
-    /** The timeframe `preset` shows in, from the bars on the chart now. */
-    private timeframeForPreset;
-    /** Whether a switch to `tf` brings bars: the feed serves it, or the bars here resample to it. */
-    private canShowTimeframe;
     /** Fill the screen with the widget, or leave fullscreen. */
     toggleFullscreen(): void;
     /** A drawing tool's name in the widget's language. */
     private drawingToolName;
     /** The chart container's top-left in the widget root's coordinates. */
     private chartOffset;
-    /** `updateSelectionToolbar` on the next frame, once, while the toolbar shows. */
-    private scheduleSelectionToolbar;
-    /**
-     * Show the selection toolbar over the selected drawings, or hide it: when
-     * nothing is selected, or while a tool, the eraser or the zoom area is on.
-     */
-    private updateSelectionToolbar;
-    /**
-     * Type a text drawing's words in place, over its box: Enter or a click away
-     * keeps them, Escape puts them back. One just drawn (`justDrawn`) is taken
-     * back on Escape or with no words. False when its box is not on the chart
-     * (hidden, its text turned off): the settings ask for the words instead.
-     */
-    private editTextInPlace;
-    /** Open a drawing's settings (double-click on it, or the object tree's settings button). */
-    private openDrawingSettings;
-    private showDrawingSettings;
-    /** Save a drawing's look as a template of its tool, asking for its name over the drawing's settings. */
-    private promptSaveDrawingTemplate;
-    /** Add a "price crosses this drawing" alert and say so. */
-    private addDrawingAlert;
-    /** The menu of a right-clicked drawing; the chart has selected it (and its group) by now. */
-    private openDrawingMenu;
-    private runDrawingMenuAction;
-    /** What the chart's menus can offer here, and how the chart is set now. */
-    private chartMenuContext;
-    /** The indicators "Remove indicators" takes away: a comparison with another symbol stays, as it has a dialog of its own. */
-    private removableIndicators;
-    /**
-     * The exchange's zone, offered when the chart knows one (the symbol's, or
-     * its market's) or the adapter can name the symbol's; its zone is null
-     * while unknown.
-     */
-    private exchangeChoice;
-    /** The time zones on offer, the exchange's among them when there is one. */
-    private timezoneChoices;
-    /**
-     * Open a chart menu at (x, y) in the chart's pixels, the host's own entries
-     * last; nothing when it has no entries.
-     */
-    private openChartMenu;
     /**
      * Turn switches on or off while running, by name (`WIDGET_FEATURES`): a
      * name without a dot is a whole capability (`alerts`, `settings`), a dotted
@@ -549,48 +423,24 @@ export declare class ChartWidget {
      * name it doesn't know.
      */
     getSlot(name: import('./types.js').WidgetSlot): HTMLElement | null;
-    private runChartMenuAction;
     /** Open or close the account panel (no argument: the other way from now). */
     toggleAccountPanel(open?: boolean): void;
-    /** The order ticket, at a price from the chart (or the market). */
-    private openOrderTicket;
-    /** A market's rules for the order ticket (`setMarket`): its step, the day's limits, its lot. */
-    private orderRules;
-    /** Redraw the account panel once a frame at most (ticks, fills and order changes come in bursts). */
-    private refreshAccountSoon;
-    private refreshAccount;
-    /** Ask for a limit or stop order at `price` (one unit), and say so. */
-    private placeOrderAt;
     /** The time now in the display zone ("14:05:09") and the zone's offset ("UTC+7"), for the status bar's clock. */
     private clockNow;
     /** Whether every drawing is locked, and every one hidden: the sidebar's lock all and hide all say so. */
     private refreshDrawingsState;
-    /** The status bar's scale switches as the chart is now (a shared link or your code may have set it). */
-    private refreshScaleSwitches;
-    /** `mode` on, or back to a regular scale when it is on already, through the settings. */
-    private toggleScaleMode;
     /** The display timezone from the settings; 'exchange' is the zone the chart resolved it to. */
     private displayTimezone;
     private toggleGoToDate;
     private toggleLoadedGoToDate;
     /** A moment to centre, or a span to show edge to edge, from the Go to dialog. */
     private goTo;
-    /** Pinned timeframes that are still on offer, shortest first. */
-    private pinnedTimeframes;
-    /** The timeframe menu's rows, typed intervals marked so they can be removed. */
-    private timeframeMenu;
-    /** A typed interval: switch to it, adding and pinning it when it is new. False when it isn't one. */
-    private handleAddTimeframe;
     /** A note by a signal marker: its source or label, side, confidence, price and time; null hides it. */
     private showMarkerTip;
-    /** A typed interval: one on offer is picked; another joins the menu (not the toolbar's pins). */
-    private selectTypedTimeframe;
     /** Put a template's indicators in place of the chart's (one undo step). */
     private applyIndicatorTemplate;
     /** Save the chart's indicators as a template, asking for its name. */
     private promptSaveIndicatorTemplate;
-    private handleRemoveTimeframe;
-    private handleToggleTimeframeFavorite;
     /**
      * Load the widget's base series. Prefer this over `getChart().setData()` so
      * client-side timeframe resampling has a finest-resolution source to
@@ -628,9 +478,6 @@ export declare class ChartWidget {
     private timeToKeepInView;
     private handleDataUpdate;
     private setConnectionState;
-    /** The depth ladder, a page of the dock: open or shut it (the Trade menu's entry). */
-    private toggleLadder;
-    private toggleAlerts;
     private handleToggleFavorite;
     /**
      * Encode the current view (symbol, timeframe, chart type, scale,
@@ -639,22 +486,6 @@ export declare class ChartWidget {
      * host's features set, from where they set them).
      */
     exportState(): string;
-    /**
-     * A link's settings, for this visit: shown, but neither kept nor told.
-     * They are someone else's choices (an upside-down scale, a hidden price),
-     * so `persistSettings` keeps the viewer's own in their place until the
-     * viewer changes them, and listeners hear of them with the next change.
-     */
-    private showLinkSettings;
-    /** `settings` with each one still as a link set it back to the viewer's own: what `persistSettings` keeps. */
-    private ownSettings;
-    /**
-     * Settings the viewer or the host just set: a link's no more, so from here
-     * on they are kept as they are, the link's value too when it is picked
-     * again on purpose. Kept at once, since a pick of the value on screen (a
-     * Reset where the link set the defaults) changes nothing to tell.
-     */
-    private claimSettings;
     /** Restore a view from an `exportState()` string. Returns false if malformed. */
     importState(encoded: string): Promise<boolean>;
     /**
@@ -672,47 +503,8 @@ export declare class ChartWidget {
     setDepth(depth: DepthData | null): void;
     /** Begin a draggable bracket order at the latest price and show the action bar. */
     startBracket(side: 'buy' | 'sell'): void;
-    /**
-     * The bar under the pointer and the close before it. On candles the data
-     * bar at the index, as it is now (a live tick moves it); on Renko and the
-     * like the brick the crosshair reported, whose index is not the data's.
-     */
-    private hoveredBar;
-    private buildDataWindowModel;
-    private toggleDataWindow;
-    private toggleObjects;
-    /**
-     * The dock's pages, in the rail's order: the watchlist, alerts, objects,
-     * the data window, the symbol info and the depth ladder, all shut to start
-     * with. Each draws itself as it shows, and says so on the toolbar's button.
-     */
-    private setupDock;
-    /**
-     * The dock and the widget's width. Going narrow (a phone, a rotated
-     * tablet) shuts any panel: it would be a sheet over the chart. No panel
-     * opens by itself: the chart has the room until one is asked for.
-     */
-    private fitDockToWidth;
-    /** Whether the rail shows now: on, and the widget not narrow. */
-    private railShown;
-    /**
-     * The rail's Tab stop on a button that shows, and the toolbar's alerts and
-     * objects buttons hidden while the rail has its own for them (so the
-     * "more" menu leaves them out too).
-     */
-    private syncRail;
-    /** Where the keyboard goes when a panel shuts and the rail can't take it: its toolbar button, or "more" on a phone. */
-    private panelFocusTarget;
-    /** A panel shut by its own close button: by hand. */
-    private closePanelByHand;
     private openIndicatorSettings;
     private showIndicatorSettings;
-    private refreshObjects;
-    private handleAddCompare;
-    /** What is compared with the chart's symbol now, as the compare dialog lists it. */
-    private comparedNow;
-    /** The compare dialog's list, after something was compared or taken off. */
-    private refreshCompareDialog;
     /**
      * Compare with another symbol: its percent change on the price scale
      * (`'percent'`, the default), its price on a scale of its own (`'scale'`)
@@ -723,100 +515,8 @@ export declare class ChartWidget {
      * no bars at the chart's interval, nothing is added and a toast says why.
      */
     addCompareSymbol(symbol: string, way?: CompareWay): Promise<void>;
-    /**
-     * A compare that is an indicator (on its own scale or pane, a spread, a
-     * correlation), its bars first, as the percent way does. A symbol the feed
-     * can't serve at this interval then adds nothing, rather than an empty
-     * line that stays in the chart's saves. The bars go to the chart before
-     * the indicator, so it finds them there and asks for none.
-     */
-    private addCompareIndicator;
-    /**
-     * The other symbol's bars at the chart's interval, for a compare about to
-     * be added: fetched again when the interval changed while they loaded, so
-     * they are checked, and added, at the one on screen. Null, with a toast,
-     * when they fail or there are none.
-     */
-    private fetchCompareBars;
-    /** The other symbol's bars didn't come: the adapter's reason, or that they failed. */
-    private sayCompareFailed;
-    /** Take a compare off, an overlay or an indicator, as the compare dialog and Objects do. */
-    private removeCompared;
-    private handleRemoveCompare;
-    /** A compare line the host added on the chart itself: the widget holds no scale nor list for it. */
-    private removeHostCompare;
-    /** `id` is a symbol compared in percent (a line, not an indicator). */
-    private isPercentCompare;
-    /**
-     * How many bars of another symbol to fetch: as many as the chart has (it
-     * may have paged older ones in), so a compare starts where the chart does.
-     */
-    private compareDepth;
-    /**
-     * Percent compares hold a regular price scale in percent: the user's has
-     * not been picked meanwhile, and the chart draws their lines (Renko, Kagi
-     * and the like draw none).
-     */
-    private holdsPercentScale;
-    /**
-     * The scale on screen: the user's, or percent while percent compares hold a
-     * regular one. Logarithmic, percentage and indexed to 100 are left alone: a
-     * log scale draws the compare lines true, and the other two read them right.
-     */
-    private effectiveScaleMode;
-    /** The scale the user picked, for a shared link, a layout and the settings: never the percent a compare holds. */
-    private userScaleMode;
-    /** The settings as the dialog shows them: the scale on screen. */
-    private shownSettings;
-    /** Put the chart's price scale on the one it should show now. */
-    private showScaleMode;
-    /** The first percent compare holds the scale in percent; the last one gone lets it go. */
-    private holdCompareScale;
-    /** The scale a hold of percent compares puts on screen, in the status bar and in the settings. */
-    private showHeldScale;
-    /**
-     * Bars of a symbol the chart's indicators read (a compare on its own
-     * scale, a spread), at the chart's interval. A later interval wins.
-     */
-    private loadSymbolSeries;
-    /** Refetch every comparison overlay at the current symbol/timeframe. */
-    private refetchCompares;
-    /** Each percent compare's bars again, as deep as the chart's, at its interval. The latest round wins. */
-    private refetchPercentCompares;
-    /**
-     * Older bars in: each percent compare's older stretch, so its line starts
-     * where the chart does. One round at a time: pages that load meanwhile
-     * get one more round, for what is missing by then.
-     */
-    private extendPercentCompares;
-    /**
-     * Each percent compare's bars before its first, as many as the chart has
-     * before it; from a feed that can't page back, its bars again, as deep as
-     * the chart's. A round of full fetches meanwhile (a new interval) drops them.
-     */
-    private fetchOlderCompares;
-    /**
-     * A percent compare's bars fetched again `depth` deep, from a feed that
-     * can't page back. Fewer than asked, or none older than `first`: the
-     * feed's history starts there, and no page asks again.
-     */
-    private deepenCompareBars;
-    /** A percent compare's older bars in front of its own; none older: the feed's history starts there. */
-    private prependCompareBars;
-    /** A percent compare's line on new bars at `timeframe`, which may reach further back again. */
-    private setCompareBars;
-    /** A percent compare's bars at `timeframe` didn't come: it keeps the ones it has. */
-    private compareFailedAt;
-    private refreshAlerts;
     /** The prices the panels show, written again in the decimals the chart has now. */
     private refreshPriceTexts;
-    private alertListItem;
-    /** An alert in words, for a toast or a notification: "Price crossing EMA 20", "RSI greater than 70". */
-    private alertText;
-    /** Price + every active indicator line, as selectable alert sources. */
-    private buildAlertSources;
-    /** Latest value for an alert source channel (price or indicator line). */
-    private getAlertChannelValue;
     /**
      * Money in the quote's units (a stop's risk, an order's value), in the
      * number locale: to the decimals of the price step, two at most (a forex
@@ -853,10 +553,6 @@ export declare class ChartWidget {
     /** "Save as default": new indicators of the kind start like this one, here and next time. */
     private saveIndicatorDefault;
     private handleRemoveIndicator;
-    private toggleCommandPalette;
-    private buildCommandItems;
-    /** Whether the widget has what a command works on: a watchlist, a feed to compare from, layouts to save to. */
-    private commandThere;
     /**
      * `keys` as a command's shortcut, where they work: their switch on (and
      * what they need there), and no shortcut of the host's on them instead.
@@ -864,17 +560,6 @@ export declare class ChartWidget {
     private keysShown;
     /** The shortcut sheet: the keys switched on, and the host's. */
     private openHotkeySheet;
-    /** Whether a command's switch (when it has one) is on. */
-    private commandOn;
-    /**
-     * The trash button's menu: the drawings, the indicators, or both, each with
-     * how many would go (locked drawings stay). Nothing to remove, no menu; a
-     * second press closes it.
-     */
-    private openClearMenu;
-    /** Remove the drawings, the indicators or both, as one undo step, and leave any drawing tool. */
-    private removeAll;
-    private handleAction;
     private handleDrawingTool;
     /** The cursor button: no tool, no eraser, no zoom box. */
     private handleCancelDrawing;
@@ -882,8 +567,6 @@ export declare class ChartWidget {
     /** The magnet button goes off → weak → strong → off. */
     private handleToggleMagnet;
     private handleToggleTheme;
-    private openSettings;
-    private showSettings;
     /** A dialog's code, loaded the first time it opens; a failed load says so. */
     private lazyPart;
     /**
@@ -892,20 +575,10 @@ export declare class ChartWidget {
      * one opens it (another indicator's settings, another tab), once.
      */
     private whenLoaded;
+    /** A toggle pressed again while its dialog's code loads: the dialog no longer opens. Whether one was waiting. */
+    private cancelWaiting;
     /** The whole series in view, the price scale fitted to it (the menus' Reset, Alt+R). */
     private resetView;
-    /** The settings closed: OK keeps what they changed as one undo step, Cancel puts it back as it was on opening. */
-    private endSettingsEdit;
-    /**
-     * The keys a change touched: in the open settings, what Cancel and the
-     * undo step go by (and what OK takes from a link); outside them, a link's
-     * no more.
-     */
-    private touchSettings;
-    /** A chart template in place of the chart's look: its switches, and its colours over the theme's. */
-    private applyChartTemplate;
-    /** Save the chart's look as a template, asking for its name over the open settings. */
-    private promptSaveChartTemplate;
     /**
      * Show a transient toast inside the widget. Auto-dismisses after 3.5s.
      * Used by the drag-drop importer for success / failure feedback, but
@@ -952,38 +625,12 @@ export declare class ChartWidget {
      * safe to give back right after the constructor.
      */
     setSettings(patch: Partial<ChartSettingsState>): void;
-    /**
-     * A patch without auto-scale off while the chart has no bars. Off holds the
-     * price range on screen; before the first bars there is none, and the chart
-     * would keep its empty 0 to 1 for every series after them.
-     */
-    private withoutEarlyFreeze;
     /**
      * Hear of each change to the Chart Settings, with `getSettings()`: once
      * when the settings dialog closes with OK, never for Cancel or for a
      * change that leaves them as they were. Returns the function that stops it.
      */
     onSettingsChange(listener: (settings: ChartSettingsState) => void): () => void;
-    /**
-     * The settings the chart says itself, over the widget's: what a host set
-     * on `getChart()` directly, a scale a drag or a switched-off feature
-     * changed, a type's own settings a layout brought. The scale is the
-     * user's, never the percent a compare holds.
-     */
-    private syncSettingsFromChart;
-    /**
-     * A patch without what the host's features switched off: a bar countdown,
-     * a legend, a volume or a log scale that isn't there stays off. Keys given
-     * no value are left out too.
-     */
-    private allowedSettings;
-    /** The settings the user kept in this browser (`persistSettings`) back on the chart; from here on each change is kept and told. */
-    private restoreKeptSettings;
-    /** Once telling has begun, the settings as they are now count as told: the next change is measured from them. */
-    private markSettingsTold;
-    /** The settings changed: kept (`persistSettings`) and told to the listeners, unless they are as last time. */
-    private publishSettings;
-    private setupLayouts;
     /** Save into the open layout, or ask for a name when there is none. */
     saveLayout(): Promise<void>;
     /** Open a saved layout by id; `false` when it could not be. */
@@ -993,8 +640,6 @@ export declare class ChartWidget {
      * Useful as an "Reset layout" command in user-facing menus.
      */
     clearSavedLayout(symbol?: string): void;
-    private applySymbolLayout;
-    private flushActiveLayout;
     /** Rebuild the chip strip from the chart's indicator instances. */
     private syncIndicatorsFromChart;
     /** Open the indicators dialog, or close it when it is open. */
@@ -1009,170 +654,47 @@ export declare class ChartWidget {
     private templateNames;
     /** Open (or close) bar replay with its scrubber — what the toolbar's Replay button does. */
     toggleReplay(): void;
-    /**
-     * Open replay in "pick a start bar" mode: the bars right of the pointer
-     * are shaded, and a click cuts the chart there and waits paused. Play
-     * starts from a default point; "random bar" picks one.
-     */
-    private enterReplay;
-    /** While picking the start bar: the shade over the bars a pick would hide. */
-    private showReplayShade;
-    private removeReplayShade;
-    /**
-     * Select bar, inside the replay: it pauses and picks again among the bars
-     * shown, so the bars still to come stay hidden, the view stays and grid
-     * followers go on. Cancel (or Esc) comes back to the same place.
-     */
-    private pickReplayBarAgain;
-    /** Cancel picking: back to the replay when there is one, else out of it. */
-    private cancelReplayPick;
-    /**
-     * Where the bar sits: on the main pane's foot (bottom panes stay
-     * readable), centred on its plot, in the tier its width allows; and how
-     * high it reaches, for the toasts and the drawing button to clear it.
-     */
-    private layoutReplayBar;
-    /**
-     * How high the bar reaches over the widget's foot and its body's, for the
-     * toasts and the drawing button to clear it. Also run as the panel follows
-     * the chart: the bar's height changes with its rows and its words.
-     */
-    private liftOverReplayBar;
-    /** Where the plot starts in the body, for the phone's drawing button to sit over it. */
-    private placeDrawingButton;
-    private bodyEl;
-    /**
-     * Where the replay is, as the readout says it: the step's open time in
-     * the display timezone and the widget's language; the date alone on a
-     * daily chart and above, seconds under a minute (or with no interval),
-     * the year only when it isn't this one.
-     */
-    private replayTimeText;
-    /** The chart's bars the replay goes through (not its steps), or those loaded before it starts. */
-    private replayBarCount;
-    private readonly hideReplayShade;
     /**
      * Open replay (if it isn't open) and start it at bar `index` — paused, or
      * playing when `play` is set — skipping the pick-a-bar step.
      */
     replayFrom(index: number, play?: boolean): void;
-    /**
-     * The steps a replay can take on this interval, the one picked kept while
-     * it is still one of them (else whole bars).
-     */
-    private replayStepMenu;
-    /** The interval changed: the step menu offers its steps. */
-    private refreshReplaySteps;
-    /**
-     * The replay went on over new bars at the same time: the panel shows their
-     * total, and a replay in finer steps fetches them for the new bars and
-     * goes on from the bar it is on.
-     */
-    private afterReplayCarryOver;
-    /**
-     * A bar picked while the next bars loaded: once they are in, start the replay at the bar
-     * holding its time; let it go if they failed or the pick was left.
-     */
-    private startPickedReplay;
-    /** Whether the bars on screen are about to be replaced: a new symbol's or interval's on their way. */
-    private seriesPending;
-    /** The panel follows the chart, and whether the bars are on their way, a few times a second. */
-    private watchReplayBar;
-    /**
-     * Cut the chart at `index` and wait paused (or play at once). `ofBars`:
-     * `index` is one of the chart's bars (a pick), not a step of the replay.
-     */
-    private startReplayAt;
-    private replayStepsKeyNow;
-    /** How many steps of `tf` make a bar of the chart (1 for whole bars, or a chart without an interval). */
-    private replayStepsPerBar;
-    /** Finer intervals a replay can step through: they divide the chart's, and the feed (or the bars loaded) has them. */
-    private replayStepOptions;
-    /** Whether the feed serves `tf`, or the bars loaded build it. */
-    private hasReplayStep;
-    /** The finer interval the step picked stands for (`'auto'` worked out here); null for whole bars. */
-    private replayStepInterval;
-    /**
-     * Whether the chart fetches a replay's finer bars itself: its bars form, a
-     * step is picked and the feed pages back. A feed that can't page back gets
-     * its finer bars fetched here, in one request, as before.
-     */
-    private chartFetchesReplaySteps;
-    /** The finer bars for a replay in `tf` steps: from the feed, or built from the bars loaded. Null when there are none. */
-    private replayStepsFor;
-    /**
-     * The zone the feed's wrapper builds `tf` in for `symbol` ('' when the feed
-     * serves it): after no answer about the symbol it builds on UTC's days
-     * until the chart loads the symbol afresh, so steps fetched before then
-     * are stale after it.
-     */
-    private builtStepsZone;
-    /** Bars available to replay: the whole series, not the slice on screen. */
-    private replayTotal;
-    /** Mirror the replay engine in the bar; close it if the session ended elsewhere. */
-    private syncReplayBar;
-    private stepReplay;
-    /**
-     * Replay shortcuts: Shift+←/→ step one bar, Space on the chart plays or
-     * pauses, Escape cancels picking a start bar. Only for the widget used
-     * last, with focus in it (or nowhere), not while typing or in a dialog.
-     */
-    private handleReplayKey;
-    /** Focus on the chart itself (its container or the canvas in it), not on a control over it. */
-    private onChartSurface;
-    private toggleReplayPlay;
-    private replayBarAtEnd;
-    private positionReplayShade;
-    /** Leave replay and return to the live series (with updates that arrived meanwhile). */
-    private exitReplay;
-    private teardownReplayUi;
-    /**
-     * Focus was in the bar: back to the toolbar's Bar replay button, or the
-     * "more" menu that folds it on a narrow toolbar, or the chart.
-     */
-    private focusAfterReplay;
-    /** `told` false leaves the change unkept and untold (a link's). */
-    private applySettings;
-    private resetSettings;
-    /**
-     * A change to the look in the settings: style keys on the user's layer (null
-     * takes one away), kept with the theme they were picked on, and in the
-     * chart's undo history. A burst on the same keys (a colour dragged across
-     * the picker) is one step.
-     */
-    private changeStyle;
-    /**
-     * A settings change the user made: applied, and put in the chart's undo
-     * history with its drawings and indicators. A burst on the same settings
-     * (a colour dragged across the picker) is one step.
-     */
-    private changeSettings;
-    /**
-     * The user's overrides on `keys` (null: none set), with the theme they go
-     * with: what an undo of the look puts back.
-     */
-    private settingsStyle;
-    /**
-     * Settings back as they were (an undo or redo), shown in the settings if
-     * they're open; `held` puts back whether percent compares held the scale.
-     */
-    private restoreSettings;
+    /** What the replay reads of the widget and asks of it. */
+    private replayHost;
+    /** Where the plot starts in the body, for the phone's drawing button to sit over it. */
+    private placeDrawingButton;
+    private bodyEl;
     private connectStream;
-    /** Redraw the on-chart indicator list on the next frame (coalesced). */
-    private scheduleLegend;
-    private renderLegend;
-    /** A pane's button on the chart. */
-    private runPaneAction;
-    /**
-     * An indicator's "more" menu: into the pane above or below it (the price
-     * pane at the top), a pane of its own, back to the price pane; then its
-     * settings and remove.
-     */
-    private openLegendMenu;
     private updateUI;
+    /** Mark `role` open or closed; the toolbar's effect shows it. */
+    private markOpen;
     private resolveIsDark;
     private resolveTheme;
     private isColorDark;
+    /** What WidgetCompares reads of the widget and asks of it. */
+    private comparingHost;
+    /** What WidgetWatchlists reads of the widget and asks of it. */
+    private watchingHost;
+    /** What WidgetAlerts reads of the widget and asks of it. */
+    private alertingHost;
+    /** What WidgetTrading reads of the widget and asks of it. */
+    private tradingHost;
+    /** What WidgetMenus reads of the widget and asks of it. */
+    private menusHost;
+    /** What WidgetLegendView reads of the widget and asks of it. */
+    private legendHost;
+    /** What WidgetCommands reads of the widget and asks of it. */
+    private commandsHost;
+    /** What WidgetLayouts reads of the widget and asks of it. */
+    private layoutsHost;
+    /** What WidgetDockArea reads of the widget and asks of it. */
+    private dockingHost;
+    /** What WidgetChartSettings reads of the widget and asks of it. */
+    private chartSettingsHost;
+    /** What WidgetDrawingEdit reads of the widget and asks of it. */
+    private drawingEditHost;
+    /** What WidgetIntervals reads of the widget and asks of it. */
+    private intervalsHost;
 }
 export { indicatorChipLabel };
 type ActiveIndicator = ReturnType<Chart['getActiveIndicators']>[number];