gloomberb 0.20.13 → 0.20.14
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +2 -1
- package/patches/@opentui%2Fcore@0.3.2.patch +22 -4
- package/src/account/auth-dialog.tsx +22 -4
- package/src/account/auth-form.tsx +6 -1
- package/src/account/checkout-handoff.tsx +7 -14
- package/src/account/device-signin-dialog.tsx +35 -24
- package/src/api-client/crypto-markets.ts +10 -0
- package/src/api-client/errors.ts +3 -1
- package/src/api-client/money-markets.ts +7 -0
- package/src/api-client/request.ts +12 -2
- package/src/architecture/floating-promise-allowlist.json +0 -1
- package/src/brokers/signed-in/sign-in-dialog.tsx +38 -38
- package/src/cli/commands/market.ts +95 -23
- package/src/cli/commands/overview.ts +18 -4
- package/src/cli/errors.ts +3 -1
- package/src/cli/freshness.ts +7 -2
- package/src/cli/glossary.ts +10 -5
- package/src/cli/helpers.ts +8 -16
- package/src/cli/history-export.ts +4 -0
- package/src/cli/known-gaps.ts +2 -2
- package/src/cli/listing-arg.ts +79 -11
- package/src/cli/not-a-ticker.ts +4 -0
- package/src/cli/pane-functions/catalog.ts +29 -8
- package/src/cli/pane-functions/headless.ts +5 -2
- package/src/cli/pane-functions/options.ts +7 -0
- package/src/cli/pane-functions/resolver.ts +61 -15
- package/src/cli/result.ts +22 -4
- package/src/cli/symbol-args.ts +5 -3
- package/src/cli/symbol-list.ts +23 -10
- package/src/cli/symbol-rows.ts +135 -3
- package/src/cli/treasury-yields.ts +15 -1
- package/src/components/chart/composite/format.ts +2 -1
- package/src/components/chart/composite/panel-surface/axis-markers.ts +133 -0
- package/src/components/chart/composite/panel-surface/level-labels.tsx +78 -0
- package/src/components/chart/composite/panel-surface/overlays.ts +108 -0
- package/src/components/chart/composite/panel-surface/pan-coast.ts +54 -0
- package/src/components/chart/composite/panel-surface/panel-cursor.tsx +138 -0
- package/src/components/chart/composite/panel-surface/panel-levels.ts +47 -0
- package/src/components/chart/composite/panel-surface/plot-gestures.ts +403 -0
- package/src/components/chart/composite/panel-surface/plot-pointer.ts +65 -0
- package/src/components/chart/composite/panel-surface/plot-wheel.ts +102 -0
- package/src/components/chart/composite/panel-surface/pointer.ts +12 -0
- package/src/components/chart/composite/panel-surface/props.ts +79 -0
- package/src/components/chart/composite/panel-surface/tool-readout.ts +151 -0
- package/src/components/chart/composite/panel-surface/value-axis-gestures.ts +152 -0
- package/src/components/chart/composite/panel-surface.tsx +81 -1177
- package/src/components/command-bar/commands/collection-list.ts +1 -0
- package/src/components/command-bar/routes/root/results.ts +3 -2
- package/src/components/command-bar/routes/root/runtime.ts +3 -2
- package/src/components/command-bar/routes/root/selection.ts +3 -2
- package/src/components/command-bar/routes/root/shortcuts.ts +15 -0
- package/src/components/layout/pane/title.ts +10 -4
- package/src/components/pane-settings-dialog/tui.tsx +6 -3
- package/src/components/pane-settings-dialog.tsx +2 -1
- package/src/components/pane-template-wizard.tsx +2 -0
- package/src/components/ui/choice-dialog.tsx +1 -1
- package/src/components/ui/confirm-dialog.tsx +3 -2
- package/src/components/ui/frame.tsx +7 -3
- package/src/components/ui/icon.tsx +4 -2
- package/src/components/ui/list-view.tsx +8 -0
- package/src/components/ui/number-prompt-dialog.tsx +2 -1
- package/src/components/use-pane-notice-footer.tsx +3 -1
- package/src/docs/snapshot.json +2 -2
- package/src/i18n/es.ts +1 -0
- package/src/i18n/ja.ts +1 -0
- package/src/i18n/ko.ts +1 -0
- package/src/i18n/zh-cn.ts +1 -0
- package/src/i18n/zh-tw.ts +1 -0
- package/src/market-data/market/format.ts +35 -1
- package/src/market-data/quotes/contributions.ts +13 -0
- package/src/market-data/quotes/export-identity.ts +36 -1
- package/src/market-data/quotes/resolution.ts +16 -0
- package/src/plugins/builtin/account-management/password-dialog.tsx +2 -2
- package/src/plugins/builtin/analytics/risk-client.ts +12 -2
- package/src/plugins/builtin/analytics/risk-headless.ts +66 -6
- package/src/plugins/builtin/analytics/risk-math.ts +23 -6
- package/src/plugins/builtin/analytics/risk-model.ts +20 -9
- package/src/plugins/builtin/analytics/risk-pane.tsx +2 -2
- package/src/plugins/builtin/chart-composer/catalog-inventory.ts +5 -2
- package/src/plugins/builtin/chart-composer/editor.tsx +1 -0
- package/src/plugins/builtin/chart-composer/pane.tsx +1 -1
- package/src/plugins/builtin/chart-composer/quick-add.tsx +4 -1
- package/src/plugins/builtin/chart-composer/series-catalog.ts +17 -1
- package/src/plugins/builtin/cloud/plugin.tsx +2 -0
- package/src/plugins/builtin/cloud/thesis/module.tsx +2 -0
- package/src/plugins/builtin/cloud/upgrade-status-widget.tsx +6 -2
- package/src/plugins/builtin/cpi/headless.ts +6 -1
- package/src/plugins/builtin/cpi/model.ts +17 -0
- package/src/plugins/builtin/cpi/pane.tsx +3 -1
- package/src/plugins/builtin/crypto-board/client.ts +6 -1
- package/src/plugins/builtin/crypto-board/headless.ts +10 -2
- package/src/plugins/builtin/crypto-board/model.ts +89 -11
- package/src/plugins/builtin/crypto-board/pane.tsx +20 -5
- package/src/plugins/builtin/dividend-yield/client.ts +24 -2
- package/src/plugins/builtin/dividend-yield/headless.ts +4 -2
- package/src/plugins/builtin/dividend-yield/ranking.ts +2 -1
- package/src/plugins/builtin/dividend-yield/view.ts +5 -1
- package/src/plugins/builtin/earnings/history-table.ts +8 -0
- package/src/plugins/builtin/earnings-ripple/index.tsx +2 -0
- package/src/plugins/builtin/econ/calendar-model.ts +17 -1
- package/src/plugins/builtin/econ/fred-catalog.ts +33 -4
- package/src/plugins/builtin/econ-statistics/headless.ts +21 -0
- package/src/plugins/builtin/macro-day/headless.ts +21 -10
- package/src/plugins/builtin/macro-day/model.ts +40 -3
- package/src/plugins/builtin/macro-day/pane.tsx +26 -8
- package/src/plugins/builtin/macro-day/releases.ts +24 -1
- package/src/plugins/builtin/money-markets/client.ts +4 -1
- package/src/plugins/builtin/money-markets/headless.ts +15 -4
- package/src/plugins/builtin/money-markets/index.tsx +1 -1
- package/src/plugins/builtin/money-markets/pane.tsx +7 -1
- package/src/plugins/builtin/portfolio-list/cli/bulk-symbols.ts +4 -2
- package/src/plugins/builtin/portfolio-list/cli/period-report.ts +61 -11
- package/src/plugins/builtin/portfolio-list/cli/portfolio-command.ts +11 -3
- package/src/plugins/builtin/portfolio-list/cli/watchlist-command.ts +2 -0
- package/src/plugins/builtin/portfolio-list/headless.ts +33 -6
- package/src/plugins/builtin/portfolio-list/pane/index.tsx +5 -3
- package/src/plugins/builtin/portfolio-list/pane/period-pnl.ts +24 -6
- package/src/plugins/builtin/portfolio-list/period-pnl.ts +16 -1
- package/src/plugins/builtin/portfolio-list/summary/index.tsx +4 -1
- package/src/plugins/builtin/portfolio-list/summary/totals.ts +6 -4
- package/src/plugins/builtin/portfolio-list/table.tsx +25 -15
- package/src/plugins/builtin/shared/cloud-upgrade.ts +4 -2
- package/src/plugins/builtin/shared/cpi-year-gap.ts +67 -0
- package/src/plugins/builtin/ticker-detail/adr-pair/headless.ts +45 -2
- package/src/plugins/builtin/ticker-detail/headless.ts +26 -1
- package/src/plugins/builtin/ticker-detail/overview/components.tsx +4 -5
- package/src/plugins/builtin/ticker-detail/overview/model.ts +4 -1
- package/src/plugins/builtin/ticker-detail/overview-tab.tsx +10 -2
- package/src/portfolio/collection-name.ts +2 -1
- package/src/portfolio/column-values.ts +14 -4
- package/src/portfolio/listed-symbol.ts +4 -2
- package/src/portfolio/period-pnl.ts +51 -1
- package/src/renderers/dom/dialog-host.tsx +5 -5
- package/src/renderers/electrobun/view/remote/capability-invoker.ts +1 -1
- package/src/renderers/opentui/dialog-host.tsx +3 -4
- package/src/sources/gloomberb-cloud/normalizers.ts +5 -0
- package/src/sources/provider-router/history.ts +5 -2
- package/src/test-support/plugin-persistence.ts +12 -0
- package/src/tickers/company-name-listing.ts +4 -3
- package/src/tickers/company-name.ts +19 -1
- package/src/tickers/instrument-coverage.ts +27 -0
- package/src/tickers/search/home-listing.ts +38 -1
- package/src/tickers/search/index.ts +3 -2
- package/src/tickers/search/ranking.ts +21 -2
- package/src/time-series/base-series.ts +4 -0
- package/src/time-series/types.ts +5 -2
- package/src/types/financials.ts +13 -0
- package/src/types/headless.ts +2 -0
- package/src/ui/dialog-stack.ts +17 -0
- package/src/ui/dialog.tsx +6 -2
- package/src/utils/crypto-pair.ts +9 -0
- package/src/utils/exchanges.ts +13 -0
- package/src/utils/financial-statements.ts +60 -3
- package/src/utils/futures-generic.ts +14 -0
- package/src/utils/trailing-dividend.ts +13 -3
|
@@ -0,0 +1,403 @@
|
|
|
1
|
+
import { useCallback, useRef, type Dispatch, type RefObject, type SetStateAction } from "react";
|
|
2
|
+
import type { useNativeRenderer } from "../../../../ui";
|
|
3
|
+
import type { MeasuredCellSize } from "../../../../ui/measured-cells";
|
|
4
|
+
import { consumeChartMouseEvent, getGlobalMouseX, type ChartMouseEvent, type LocalPlotPointer } from "../../core/pointer";
|
|
5
|
+
import { nextDrawingId, nextLevelId } from "../drawing-store";
|
|
6
|
+
import { hitTestLevel, levelGrabRatio, roundLevelValue, type ProjectedLevel } from "../levels";
|
|
7
|
+
import {
|
|
8
|
+
AXIS_DOUBLE_PRESS_MS,
|
|
9
|
+
manualValueAxes,
|
|
10
|
+
panReleaseVelocity,
|
|
11
|
+
PLOT_DOUBLE_CLICK_MS,
|
|
12
|
+
releaseEditableFocus,
|
|
13
|
+
startPanGesture,
|
|
14
|
+
type PanGesture,
|
|
15
|
+
type PanSample,
|
|
16
|
+
} from "../panel-gestures";
|
|
17
|
+
import { resolveCompositeCursorDate, unprojectCompositeValue } from "../scene";
|
|
18
|
+
import {
|
|
19
|
+
hitTestDrawings,
|
|
20
|
+
isDrawingTool,
|
|
21
|
+
resolveChartToolKind,
|
|
22
|
+
resolveDrawingFromDrag,
|
|
23
|
+
resolveZoomBoxRange,
|
|
24
|
+
shiftDrawing,
|
|
25
|
+
type ChartToolDrag,
|
|
26
|
+
} from "../tools";
|
|
27
|
+
import type { CompositeAxisDomain } from "../types";
|
|
28
|
+
import { panValueRange } from "../value-scale";
|
|
29
|
+
import type { LevelDraft } from "./panel-levels";
|
|
30
|
+
import { pointerRow } from "./pointer";
|
|
31
|
+
import type { CompositePanelSurfaceProps } from "./props";
|
|
32
|
+
|
|
33
|
+
/** What a press on the plot is doing until it lets go. */
|
|
34
|
+
type PlotDrag =
|
|
35
|
+
| PanGesture
|
|
36
|
+
| {
|
|
37
|
+
kind: "edit";
|
|
38
|
+
drawingId: string;
|
|
39
|
+
pointIndex: number | null;
|
|
40
|
+
lastXRatio: number;
|
|
41
|
+
lastYRatio: number;
|
|
42
|
+
}
|
|
43
|
+
| { kind: "level-move"; id: string }
|
|
44
|
+
| ChartToolDrag;
|
|
45
|
+
|
|
46
|
+
/**
|
|
47
|
+
* A press on the plot and what it drags: a pan (which coasts on the desktop
|
|
48
|
+
* when let go while moving), a tool in hand, a drawing or a level; with
|
|
49
|
+
* nothing to drag, a pick, or a double press that maximizes the panel.
|
|
50
|
+
*/
|
|
51
|
+
export function usePlotGestures({
|
|
52
|
+
panel,
|
|
53
|
+
scene,
|
|
54
|
+
frame,
|
|
55
|
+
viewport,
|
|
56
|
+
armedTool,
|
|
57
|
+
drawings,
|
|
58
|
+
drawColor,
|
|
59
|
+
levels,
|
|
60
|
+
plotWidth,
|
|
61
|
+
onActivate,
|
|
62
|
+
onPointerPress,
|
|
63
|
+
onPickTime,
|
|
64
|
+
onPickPrice,
|
|
65
|
+
onSelectDrawing,
|
|
66
|
+
onEditDrawing,
|
|
67
|
+
onDraw,
|
|
68
|
+
onSelectLevel,
|
|
69
|
+
onPanViewport,
|
|
70
|
+
onSetViewport,
|
|
71
|
+
onSetValueScale,
|
|
72
|
+
onDragActiveChange,
|
|
73
|
+
onToggleMaximized,
|
|
74
|
+
isDesktopWeb,
|
|
75
|
+
renderer,
|
|
76
|
+
plotSize,
|
|
77
|
+
plotAspect,
|
|
78
|
+
plotSpanFactor,
|
|
79
|
+
setToolDrag,
|
|
80
|
+
levelDomain,
|
|
81
|
+
projectedLevels,
|
|
82
|
+
levelDraftRef,
|
|
83
|
+
setLevelDraft,
|
|
84
|
+
plotPointer,
|
|
85
|
+
pointerRatios,
|
|
86
|
+
updateCursor,
|
|
87
|
+
stopCoast,
|
|
88
|
+
startCoast,
|
|
89
|
+
}: Pick<
|
|
90
|
+
CompositePanelSurfaceProps,
|
|
91
|
+
| "panel" | "scene" | "frame" | "viewport" | "armedTool" | "drawings" | "drawColor" | "levels" | "plotWidth"
|
|
92
|
+
| "onActivate" | "onPointerPress" | "onPickTime" | "onPickPrice" | "onSelectDrawing" | "onEditDrawing" | "onDraw"
|
|
93
|
+
| "onSelectLevel" | "onPanViewport" | "onSetViewport" | "onSetValueScale" | "onDragActiveChange" | "onToggleMaximized"
|
|
94
|
+
> & {
|
|
95
|
+
isDesktopWeb: boolean;
|
|
96
|
+
renderer: ReturnType<typeof useNativeRenderer>;
|
|
97
|
+
plotSize: MeasuredCellSize;
|
|
98
|
+
plotAspect: number;
|
|
99
|
+
plotSpanFactor: number;
|
|
100
|
+
setToolDrag: Dispatch<SetStateAction<ChartToolDrag | null>>;
|
|
101
|
+
levelDomain: CompositeAxisDomain | null;
|
|
102
|
+
projectedLevels: readonly ProjectedLevel[];
|
|
103
|
+
levelDraftRef: RefObject<LevelDraft | null>;
|
|
104
|
+
setLevelDraft: Dispatch<SetStateAction<LevelDraft | null>>;
|
|
105
|
+
plotPointer: (event: ChartMouseEvent) => LocalPlotPointer | null;
|
|
106
|
+
pointerRatios: (event: ChartMouseEvent) => { xRatio: number; yRatio: number } | null;
|
|
107
|
+
updateCursor: (event: ChartMouseEvent) => boolean;
|
|
108
|
+
stopCoast: () => void;
|
|
109
|
+
startCoast: (velocity: number, positionsPerCell: number) => void;
|
|
110
|
+
}) {
|
|
111
|
+
// The last press on bare plot, for a double press where the host does not count clicks.
|
|
112
|
+
const lastPlotPressRef = useRef<{ at: number; x: number; y: number } | null>(null);
|
|
113
|
+
const dragRef = useRef<PlotDrag | null>(null);
|
|
114
|
+
// Where the pointer was during a pan, for the speed it lets go at.
|
|
115
|
+
const panSamplesRef = useRef<PanSample[]>([]);
|
|
116
|
+
const startDrag = useCallback((event: ChartMouseEvent) => {
|
|
117
|
+
onActivate?.();
|
|
118
|
+
onPointerPress();
|
|
119
|
+
// The plot consumes the press, so the browser never moves focus off a text
|
|
120
|
+
// field for us. Hand it back, but only for a press that truly landed here:
|
|
121
|
+
// a dialog over the plot must keep the focus it just took.
|
|
122
|
+
if (isDesktopWeb) releaseEditableFocus(event);
|
|
123
|
+
consumeChartMouseEvent(event);
|
|
124
|
+
if (onPickTime) {
|
|
125
|
+
const pointer = plotPointer(event);
|
|
126
|
+
const date = pointer ? resolveCompositeCursorDate(scene, pointer.cellX) : null;
|
|
127
|
+
if (date) onPickTime(date);
|
|
128
|
+
return;
|
|
129
|
+
}
|
|
130
|
+
if (onPickPrice) {
|
|
131
|
+
// Only the levels' own panel has their prices; a press elsewhere picks nothing.
|
|
132
|
+
const ratios = pointerRatios(event);
|
|
133
|
+
const value = ratios && levelDomain ? unprojectCompositeValue(ratios.yRatio, levelDomain) : null;
|
|
134
|
+
if (value !== null && levelDomain) onPickPrice(roundLevelValue(value, levelDomain));
|
|
135
|
+
return;
|
|
136
|
+
}
|
|
137
|
+
// A keyboard-armed tool covers terminals that never forward modifier drags.
|
|
138
|
+
const tool = resolveChartToolKind(event.modifiers) ?? armedTool;
|
|
139
|
+
if (tool === "level" && levels?.onEdit && levelDomain) {
|
|
140
|
+
const ratios = pointerRatios(event);
|
|
141
|
+
if (!ratios) return;
|
|
142
|
+
const hit = hitTestLevel(projectedLevels, ratios.yRatio, levelGrabRatio(panel.height));
|
|
143
|
+
if (hit) {
|
|
144
|
+
onSelectLevel(hit.id);
|
|
145
|
+
if (hit.editable) dragRef.current = { kind: "level-move", id: hit.id };
|
|
146
|
+
} else {
|
|
147
|
+
const value = unprojectCompositeValue(ratios.yRatio, levelDomain);
|
|
148
|
+
if (value !== null) {
|
|
149
|
+
const id = nextLevelId();
|
|
150
|
+
levels.onEdit({ kind: "add", id, value: roundLevelValue(value, levelDomain) });
|
|
151
|
+
onSelectLevel(id);
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
updateCursor(event);
|
|
155
|
+
return;
|
|
156
|
+
}
|
|
157
|
+
if (tool) {
|
|
158
|
+
const ratios = pointerRatios(event);
|
|
159
|
+
if (!ratios) return;
|
|
160
|
+
// With a drawing tool in hand, grabbing an existing shape edits it
|
|
161
|
+
// instead of starting a new one on top of it.
|
|
162
|
+
const hit = isDrawingTool(tool)
|
|
163
|
+
? hitTestDrawings(drawings, scene, panel, ratios, plotAspect)
|
|
164
|
+
: null;
|
|
165
|
+
if (hit) {
|
|
166
|
+
onSelectDrawing(hit.drawing.id);
|
|
167
|
+
dragRef.current = {
|
|
168
|
+
kind: "edit",
|
|
169
|
+
drawingId: hit.drawing.id,
|
|
170
|
+
pointIndex: hit.pointIndex,
|
|
171
|
+
lastXRatio: ratios.xRatio,
|
|
172
|
+
lastYRatio: ratios.yRatio,
|
|
173
|
+
};
|
|
174
|
+
updateCursor(event);
|
|
175
|
+
return;
|
|
176
|
+
}
|
|
177
|
+
const started: ChartToolDrag = {
|
|
178
|
+
kind: tool,
|
|
179
|
+
startXRatio: ratios.xRatio,
|
|
180
|
+
startYRatio: ratios.yRatio,
|
|
181
|
+
endXRatio: ratios.xRatio,
|
|
182
|
+
endYRatio: ratios.yRatio,
|
|
183
|
+
path: [{ xRatio: ratios.xRatio, yRatio: ratios.yRatio }],
|
|
184
|
+
};
|
|
185
|
+
if (isDrawingTool(tool)) onSelectDrawing(null);
|
|
186
|
+
dragRef.current = { ...started, path: [...started.path] };
|
|
187
|
+
setToolDrag(started);
|
|
188
|
+
updateCursor(event);
|
|
189
|
+
return;
|
|
190
|
+
}
|
|
191
|
+
// With no tool in hand, a press on a drawing or a level picks it so Backspace
|
|
192
|
+
// or Delete can remove it; the press still pans, and one on bare plot lets go.
|
|
193
|
+
const ratios = pointerRatios(event);
|
|
194
|
+
let bare = true;
|
|
195
|
+
if (ratios) {
|
|
196
|
+
const drawingHit = drawings.length > 0 ? hitTestDrawings(drawings, scene, panel, ratios, plotAspect) : null;
|
|
197
|
+
const levelHit = !drawingHit && levels?.onEdit && levelDomain
|
|
198
|
+
? hitTestLevel(projectedLevels, ratios.yRatio, levelGrabRatio(panel.height))
|
|
199
|
+
: null;
|
|
200
|
+
onSelectDrawing(drawingHit ? drawingHit.drawing.id : null);
|
|
201
|
+
onSelectLevel(levelHit?.editable ? levelHit.id : null);
|
|
202
|
+
bare = !drawingHit && !levelHit;
|
|
203
|
+
// An order's line drags without the level tool; other levels keep the press for panning.
|
|
204
|
+
if (levelHit?.editable && levelHit.draggable) {
|
|
205
|
+
dragRef.current = { kind: "level-move", id: levelHit.id };
|
|
206
|
+
lastPlotPressRef.current = null;
|
|
207
|
+
updateCursor(event);
|
|
208
|
+
return;
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
// A double click on bare plot gives the panel the whole chart, or the
|
|
212
|
+
// others back (the terminal counts two presses on one spot). Its first
|
|
213
|
+
// press must have landed here too: a double click on a button that goes
|
|
214
|
+
// away under it (All panels) ends on this plot, and is not one of its.
|
|
215
|
+
if (!bare) lastPlotPressRef.current = null;
|
|
216
|
+
if (onToggleMaximized && bare) {
|
|
217
|
+
const now = Date.now();
|
|
218
|
+
const last = lastPlotPressRef.current;
|
|
219
|
+
const double = typeof event.detail === "number"
|
|
220
|
+
? event.detail >= 2 && !!last && now - last.at < PLOT_DOUBLE_CLICK_MS
|
|
221
|
+
: !!last && now - last.at < AXIS_DOUBLE_PRESS_MS && Math.abs(last.x - event.x) <= 1 && Math.abs(last.y - event.y) <= 1;
|
|
222
|
+
lastPlotPressRef.current = double ? null : { at: now, x: event.x, y: event.y };
|
|
223
|
+
if (double) {
|
|
224
|
+
dragRef.current = null;
|
|
225
|
+
onToggleMaximized();
|
|
226
|
+
return;
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
if (!updateCursor(event)) return;
|
|
230
|
+
const values = manualValueAxes(panel);
|
|
231
|
+
panSamplesRef.current = [{ at: performance.now(), x: getGlobalMouseX(event, renderer) }];
|
|
232
|
+
dragRef.current = {
|
|
233
|
+
...startPanGesture(
|
|
234
|
+
frame,
|
|
235
|
+
viewport,
|
|
236
|
+
plotSize.width,
|
|
237
|
+
getGlobalMouseX(event, renderer),
|
|
238
|
+
plotSpanFactor,
|
|
239
|
+
),
|
|
240
|
+
// A panel scaled by hand moves up and down with the drag as well.
|
|
241
|
+
...(values.length > 0 ? { startCellY: pointerRow(event), values } : {}),
|
|
242
|
+
};
|
|
243
|
+
}, [
|
|
244
|
+
armedTool,
|
|
245
|
+
drawings,
|
|
246
|
+
frame,
|
|
247
|
+
levelDomain,
|
|
248
|
+
levels,
|
|
249
|
+
onActivate,
|
|
250
|
+
onPickTime,
|
|
251
|
+
onPickPrice,
|
|
252
|
+
onPointerPress,
|
|
253
|
+
onSelectDrawing,
|
|
254
|
+
onSelectLevel,
|
|
255
|
+
panel,
|
|
256
|
+
plotAspect,
|
|
257
|
+
projectedLevels,
|
|
258
|
+
plotPointer,
|
|
259
|
+
plotSize.width,
|
|
260
|
+
plotSpanFactor,
|
|
261
|
+
plotWidth,
|
|
262
|
+
pointerRatios,
|
|
263
|
+
renderer,
|
|
264
|
+
scene,
|
|
265
|
+
updateCursor,
|
|
266
|
+
viewport,
|
|
267
|
+
onToggleMaximized,
|
|
268
|
+
]);
|
|
269
|
+
const pressCursor = useCallback((event: ChartMouseEvent) => {
|
|
270
|
+
onActivate?.();
|
|
271
|
+
updateCursor(event);
|
|
272
|
+
}, [onActivate, updateCursor]);
|
|
273
|
+
const dragViewport = useCallback((event: ChartMouseEvent) => {
|
|
274
|
+
const drag = dragRef.current;
|
|
275
|
+
if (!drag) return;
|
|
276
|
+
consumeChartMouseEvent(event);
|
|
277
|
+
updateCursor(event);
|
|
278
|
+
if (drag.kind === "level-move") {
|
|
279
|
+
const ratios = pointerRatios(event);
|
|
280
|
+
const value = ratios && levelDomain ? unprojectCompositeValue(ratios.yRatio, levelDomain) : null;
|
|
281
|
+
if (value === null || !levelDomain) return;
|
|
282
|
+
const draft = { id: drag.id, value: roundLevelValue(value, levelDomain) };
|
|
283
|
+
// The release reads the ref, and a quick drag lets go before the next render.
|
|
284
|
+
levelDraftRef.current = draft;
|
|
285
|
+
setLevelDraft(draft);
|
|
286
|
+
return;
|
|
287
|
+
}
|
|
288
|
+
if (drag.kind === "edit") {
|
|
289
|
+
const ratios = pointerRatios(event);
|
|
290
|
+
if (!ratios) return;
|
|
291
|
+
// Read the deltas before advancing the ref: the state updater runs later,
|
|
292
|
+
// and a mutable capture would hand it a zero move every time.
|
|
293
|
+
const deltaXRatio = ratios.xRatio - drag.lastXRatio;
|
|
294
|
+
const deltaYRatio = ratios.yRatio - drag.lastYRatio;
|
|
295
|
+
const { drawingId, pointIndex } = drag;
|
|
296
|
+
drag.lastXRatio = ratios.xRatio;
|
|
297
|
+
drag.lastYRatio = ratios.yRatio;
|
|
298
|
+
onEditDrawing(
|
|
299
|
+
drawingId,
|
|
300
|
+
(drawing) => shiftDrawing(drawing, scene, panel, deltaXRatio, deltaYRatio, pointIndex),
|
|
301
|
+
);
|
|
302
|
+
return;
|
|
303
|
+
}
|
|
304
|
+
if (drag.kind !== "pan") {
|
|
305
|
+
const ratios = pointerRatios(event);
|
|
306
|
+
if (!ratios) return;
|
|
307
|
+
drag.endXRatio = ratios.xRatio;
|
|
308
|
+
drag.endYRatio = ratios.yRatio;
|
|
309
|
+
if (drag.kind === "pencil") drag.path.push({ xRatio: ratios.xRatio, yRatio: ratios.yRatio });
|
|
310
|
+
setToolDrag({ ...drag, path: [...drag.path] });
|
|
311
|
+
return;
|
|
312
|
+
}
|
|
313
|
+
const globalX = getGlobalMouseX(event, renderer);
|
|
314
|
+
panSamplesRef.current.push({ at: performance.now(), x: globalX });
|
|
315
|
+
if (panSamplesRef.current.length > 12) panSamplesRef.current.shift();
|
|
316
|
+
if (drag.frame !== frame) {
|
|
317
|
+
// Data refreshed mid-drag. The new frame maps positions differently, so
|
|
318
|
+
// continue from where the plot is now instead of replaying the drag.
|
|
319
|
+
Object.assign(drag, startPanGesture(frame, viewport, plotSize.width, globalX, plotSpanFactor));
|
|
320
|
+
}
|
|
321
|
+
onPanViewport(
|
|
322
|
+
(globalX - drag.startGlobalX) * drag.positionsPerCell,
|
|
323
|
+
{ frame: drag.frame, from: drag.startViewport },
|
|
324
|
+
);
|
|
325
|
+
if (drag.values && drag.startCellY !== undefined) {
|
|
326
|
+
const deltaRatio = (pointerRow(event) - drag.startCellY) / Math.max(plotSize.height, 1);
|
|
327
|
+
for (const axis of drag.values) {
|
|
328
|
+
onSetValueScale(panel.id, axis.side, axis.key, panValueRange(axis.start, axis.scale, deltaRatio));
|
|
329
|
+
}
|
|
330
|
+
}
|
|
331
|
+
}, [
|
|
332
|
+
frame,
|
|
333
|
+
levelDomain,
|
|
334
|
+
onEditDrawing,
|
|
335
|
+
onPanViewport,
|
|
336
|
+
onSetValueScale,
|
|
337
|
+
plotSize.height,
|
|
338
|
+
panel,
|
|
339
|
+
plotSize.width,
|
|
340
|
+
plotSpanFactor,
|
|
341
|
+
plotWidth,
|
|
342
|
+
pointerRatios,
|
|
343
|
+
renderer,
|
|
344
|
+
scene,
|
|
345
|
+
updateCursor,
|
|
346
|
+
viewport,
|
|
347
|
+
]);
|
|
348
|
+
const finishToolDrag = useCallback(() => {
|
|
349
|
+
const drag = dragRef.current;
|
|
350
|
+
if (!drag || drag.kind === "pan") return;
|
|
351
|
+
dragRef.current = null;
|
|
352
|
+
if (drag.kind === "edit") return;
|
|
353
|
+
if (drag.kind === "level-move") {
|
|
354
|
+
const draft = levelDraftRef.current;
|
|
355
|
+
setLevelDraft(null);
|
|
356
|
+
if (draft) levels?.onEdit?.({ kind: "move", id: draft.id, value: draft.value });
|
|
357
|
+
return;
|
|
358
|
+
}
|
|
359
|
+
setToolDrag(null);
|
|
360
|
+
if (isDrawingTool(drag.kind)) {
|
|
361
|
+
const drawing = resolveDrawingFromDrag(scene, panel, drag, drawColor, nextDrawingId());
|
|
362
|
+
if (drawing) onDraw(drawing);
|
|
363
|
+
return;
|
|
364
|
+
}
|
|
365
|
+
if (drag.kind !== "zoom") return;
|
|
366
|
+
const range = resolveZoomBoxRange(scene, drag, frame.minimumSpanMs);
|
|
367
|
+
if (range) onSetViewport(range);
|
|
368
|
+
}, [drawColor, frame.minimumSpanMs, levels, onDraw, onSetViewport, panel, scene]);
|
|
369
|
+
const resetDrag = useCallback(() => {
|
|
370
|
+
const drag = dragRef.current;
|
|
371
|
+
if (drag?.kind === "pan") {
|
|
372
|
+
dragRef.current = null;
|
|
373
|
+
startCoast(panReleaseVelocity(panSamplesRef.current, performance.now()), drag.positionsPerCell);
|
|
374
|
+
return;
|
|
375
|
+
}
|
|
376
|
+
finishToolDrag();
|
|
377
|
+
}, [finishToolDrag, startCoast]);
|
|
378
|
+
// Said once per change, so a pointer move costs the chart nothing.
|
|
379
|
+
const reportedDragRef = useRef(false);
|
|
380
|
+
const reportDrag = useCallback((dragging: boolean) => {
|
|
381
|
+
if (reportedDragRef.current === dragging) return;
|
|
382
|
+
reportedDragRef.current = dragging;
|
|
383
|
+
onDragActiveChange?.(dragging);
|
|
384
|
+
}, [onDragActiveChange]);
|
|
385
|
+
const pressPlot = useCallback((event: ChartMouseEvent) => {
|
|
386
|
+
stopCoast();
|
|
387
|
+
const before = dragRef.current;
|
|
388
|
+
startDrag(event);
|
|
389
|
+
if (dragRef.current !== null && dragRef.current !== before) reportDrag(true);
|
|
390
|
+
}, [reportDrag, startDrag, stopCoast]);
|
|
391
|
+
const releasePlot = useCallback(() => {
|
|
392
|
+
resetDrag();
|
|
393
|
+
reportDrag(false);
|
|
394
|
+
}, [reportDrag, resetDrag]);
|
|
395
|
+
const handleMouseMove = useCallback((event: ChartMouseEvent) => {
|
|
396
|
+
// A release over a neighbouring pane never reaches this surface, so treat a
|
|
397
|
+
// plain move, which only fires with no button held, as the missing release.
|
|
398
|
+
finishToolDrag();
|
|
399
|
+
reportDrag(false);
|
|
400
|
+
updateCursor(event);
|
|
401
|
+
}, [finishToolDrag, reportDrag, updateCursor]);
|
|
402
|
+
return { pressPlot, pressCursor, dragViewport, releasePlot, handleMouseMove };
|
|
403
|
+
}
|
|
@@ -0,0 +1,65 @@
|
|
|
1
|
+
import { useCallback, type RefObject } from "react";
|
|
2
|
+
import type { BoxRenderable, useNativeRenderer } from "../../../../ui";
|
|
3
|
+
import type { MeasuredCellSize } from "../../../../ui/measured-cells";
|
|
4
|
+
import { consumeChartMouseEvent, getLocalPlotPointer, type ChartMouseEvent } from "../../core/pointer";
|
|
5
|
+
import type { ValueStore } from "../cursor-source";
|
|
6
|
+
import { resolveCompositeCursorDate } from "../scene";
|
|
7
|
+
import type { CompositePanelSurfaceProps } from "./props";
|
|
8
|
+
|
|
9
|
+
/**
|
|
10
|
+
* The pointer over the plot, read back into the scene's columns and rows, and
|
|
11
|
+
* the crosshair it moves: the date goes to the chart, the height stays here.
|
|
12
|
+
*/
|
|
13
|
+
export function usePlotPointer({
|
|
14
|
+
plotRef,
|
|
15
|
+
renderer,
|
|
16
|
+
plotSize,
|
|
17
|
+
plotWidth,
|
|
18
|
+
panelHeight,
|
|
19
|
+
scene,
|
|
20
|
+
pointerY,
|
|
21
|
+
onCursorDateChange,
|
|
22
|
+
}: Pick<CompositePanelSurfaceProps, "plotWidth" | "scene" | "onCursorDateChange"> & {
|
|
23
|
+
plotRef: RefObject<BoxRenderable | null>;
|
|
24
|
+
renderer: ReturnType<typeof useNativeRenderer>;
|
|
25
|
+
plotSize: MeasuredCellSize;
|
|
26
|
+
panelHeight: number;
|
|
27
|
+
pointerY: ValueStore<number | null>;
|
|
28
|
+
}) {
|
|
29
|
+
/** Where the pointer is over the plot, in the scene's columns and rows. */
|
|
30
|
+
const plotPointer = useCallback((event: ChartMouseEvent) => {
|
|
31
|
+
const pointer = getLocalPlotPointer(event, plotRef.current as unknown as Parameters<typeof getLocalPlotPointer>[1], renderer);
|
|
32
|
+
if (!pointer || (plotSize.width === plotWidth && plotSize.height === panelHeight)) return pointer;
|
|
33
|
+
return {
|
|
34
|
+
...pointer,
|
|
35
|
+
cellX: plotSize.width > 0 ? pointer.cellX * (plotWidth / plotSize.width) : pointer.cellX,
|
|
36
|
+
cellY: plotSize.height > 0 ? pointer.cellY * (panelHeight / plotSize.height) : pointer.cellY,
|
|
37
|
+
};
|
|
38
|
+
}, [panelHeight, plotSize.height, plotSize.width, plotWidth, renderer]);
|
|
39
|
+
const pointerRatios = useCallback((event: ChartMouseEvent) => {
|
|
40
|
+
const pointer = plotPointer(event);
|
|
41
|
+
if (!pointer) return null;
|
|
42
|
+
return {
|
|
43
|
+
xRatio: plotWidth <= 1 ? 0 : Math.max(0, Math.min(1, pointer.cellX / (plotWidth - 1))),
|
|
44
|
+
yRatio: panelHeight <= 1 ? 0.5 : Math.max(0, Math.min(1, pointer.cellY / (panelHeight - 1))),
|
|
45
|
+
};
|
|
46
|
+
}, [panelHeight, plotPointer, plotWidth]);
|
|
47
|
+
const updateCursor = useCallback((event: ChartMouseEvent): boolean => {
|
|
48
|
+
const pointer = plotPointer(event);
|
|
49
|
+
if (!pointer) return false;
|
|
50
|
+
const nextDate = resolveCompositeCursorDate(scene, pointer.cellX);
|
|
51
|
+
if (!nextDate) return false;
|
|
52
|
+
const nextYRatio = panelHeight <= 1
|
|
53
|
+
? 0.5
|
|
54
|
+
: Math.max(0, Math.min(1, pointer.cellY / (panelHeight - 1)));
|
|
55
|
+
pointerY.set(nextYRatio);
|
|
56
|
+
onCursorDateChange(nextDate);
|
|
57
|
+
consumeChartMouseEvent(event);
|
|
58
|
+
return true;
|
|
59
|
+
}, [onCursorDateChange, panelHeight, plotPointer, pointerY, scene]);
|
|
60
|
+
const clearCursor = useCallback(() => {
|
|
61
|
+
pointerY.set(null);
|
|
62
|
+
onCursorDateChange(null);
|
|
63
|
+
}, [onCursorDateChange, pointerY]);
|
|
64
|
+
return { plotPointer, pointerRatios, updateCursor, clearCursor };
|
|
65
|
+
}
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
import { useCallback, useEffect, useRef } from "react";
|
|
2
|
+
import { consumeChartMouseEvent, type ChartMouseEvent, type LocalPlotPointer } from "../../core/pointer";
|
|
3
|
+
import { compositeViewportPositions, resolveCompositeWheelPan, resolveCompositeWheelZoom } from "../interactions";
|
|
4
|
+
import { isVerticalWheelDirection, type PendingWheel } from "../panel-gestures";
|
|
5
|
+
import type { CompositePanelSurfaceProps } from "./props";
|
|
6
|
+
import { webFrame } from "./pointer";
|
|
7
|
+
|
|
8
|
+
/**
|
|
9
|
+
* The wheel over the plot pans it, and with Ctrl zooms it around the pointer.
|
|
10
|
+
* Trackpads fire wheel events faster than the plot can paint, so one frame
|
|
11
|
+
* absorbs every event that arrived since the last one.
|
|
12
|
+
*/
|
|
13
|
+
export function usePlotWheel({
|
|
14
|
+
frame,
|
|
15
|
+
viewport,
|
|
16
|
+
onPanViewport,
|
|
17
|
+
onZoomViewport,
|
|
18
|
+
onActivate,
|
|
19
|
+
plotWidth,
|
|
20
|
+
plotSpanFactor,
|
|
21
|
+
measuredPlotWidth,
|
|
22
|
+
cellWidthPx,
|
|
23
|
+
isDesktopWeb,
|
|
24
|
+
stopCoast,
|
|
25
|
+
plotPointer,
|
|
26
|
+
updateCursor,
|
|
27
|
+
}: Pick<CompositePanelSurfaceProps, "frame" | "viewport" | "onPanViewport" | "onZoomViewport" | "onActivate" | "plotWidth"> & {
|
|
28
|
+
plotSpanFactor: number;
|
|
29
|
+
/** The plot's measured width in cells. */
|
|
30
|
+
measuredPlotWidth: number;
|
|
31
|
+
cellWidthPx: number;
|
|
32
|
+
isDesktopWeb: boolean;
|
|
33
|
+
stopCoast: () => void;
|
|
34
|
+
plotPointer: (event: ChartMouseEvent) => LocalPlotPointer | null;
|
|
35
|
+
updateCursor: (event: ChartMouseEvent) => boolean;
|
|
36
|
+
}) {
|
|
37
|
+
const pendingWheelRef = useRef<PendingWheel | null>(null);
|
|
38
|
+
const wheelFrameRef = useRef<number | null>(null);
|
|
39
|
+
const latestWheelStateRef = useRef({ frame, viewport, onPanViewport, onZoomViewport, plotSpanFactor });
|
|
40
|
+
latestWheelStateRef.current = { frame, viewport, onPanViewport, onZoomViewport, plotSpanFactor };
|
|
41
|
+
const flushWheel = useCallback(() => {
|
|
42
|
+
wheelFrameRef.current = null;
|
|
43
|
+
const pending = pendingWheelRef.current;
|
|
44
|
+
pendingWheelRef.current = null;
|
|
45
|
+
if (!pending) return;
|
|
46
|
+
const latest = latestWheelStateRef.current;
|
|
47
|
+
if (pending.panRatio !== 0) {
|
|
48
|
+
const positions = compositeViewportPositions(latest.frame, latest.viewport);
|
|
49
|
+
const span = positions ? Math.max(positions.end - positions.start, Number.EPSILON) : 0;
|
|
50
|
+
latest.onPanViewport(pending.panRatio * span * latest.plotSpanFactor);
|
|
51
|
+
}
|
|
52
|
+
if (pending.zoomLog !== 0) {
|
|
53
|
+
latest.onZoomViewport(Math.exp(pending.zoomLog), pending.anchorRatio);
|
|
54
|
+
}
|
|
55
|
+
}, []);
|
|
56
|
+
useEffect(() => () => {
|
|
57
|
+
pendingWheelRef.current = null;
|
|
58
|
+
if (wheelFrameRef.current !== null) {
|
|
59
|
+
webFrame.cancelAnimationFrame?.(wheelFrameRef.current);
|
|
60
|
+
wheelFrameRef.current = null;
|
|
61
|
+
}
|
|
62
|
+
}, []);
|
|
63
|
+
return useCallback((event: ChartMouseEvent) => {
|
|
64
|
+
const scroll = event.scroll;
|
|
65
|
+
if (!scroll) return;
|
|
66
|
+
stopCoast();
|
|
67
|
+
onActivate?.();
|
|
68
|
+
consumeChartMouseEvent(event);
|
|
69
|
+
const pointer = plotPointer(event);
|
|
70
|
+
updateCursor(event);
|
|
71
|
+
const pending = pendingWheelRef.current ?? { panRatio: 0, zoomLog: 0, anchorRatio: 0.5 };
|
|
72
|
+
if (event.modifiers.ctrl && pointer && isVerticalWheelDirection(scroll.direction)) {
|
|
73
|
+
pending.zoomLog += Math.log(resolveCompositeWheelZoom(scroll));
|
|
74
|
+
// The anchor is a fraction of the viewport, so a pointer over the empty
|
|
75
|
+
// right offset anchors on the newest observation instead of past it.
|
|
76
|
+
pending.anchorRatio = Math.min(
|
|
77
|
+
1,
|
|
78
|
+
pointer.cellX / Math.max(plotWidth - 1, 1) * plotSpanFactor,
|
|
79
|
+
);
|
|
80
|
+
} else {
|
|
81
|
+
pending.panRatio += resolveCompositeWheelPan(scroll, measuredPlotWidth * cellWidthPx);
|
|
82
|
+
}
|
|
83
|
+
pendingWheelRef.current = pending;
|
|
84
|
+
if (!isDesktopWeb || typeof webFrame.requestAnimationFrame !== "function") {
|
|
85
|
+
flushWheel();
|
|
86
|
+
return;
|
|
87
|
+
}
|
|
88
|
+
if (wheelFrameRef.current === null) {
|
|
89
|
+
wheelFrameRef.current = webFrame.requestAnimationFrame(flushWheel);
|
|
90
|
+
}
|
|
91
|
+
}, [
|
|
92
|
+
cellWidthPx,
|
|
93
|
+
flushWheel,
|
|
94
|
+
isDesktopWeb,
|
|
95
|
+
onActivate,
|
|
96
|
+
plotPointer,
|
|
97
|
+
measuredPlotWidth,
|
|
98
|
+
plotSpanFactor,
|
|
99
|
+
plotWidth,
|
|
100
|
+
updateCursor,
|
|
101
|
+
]);
|
|
102
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import type { ChartMouseEvent } from "../../core/pointer";
|
|
2
|
+
|
|
3
|
+
/** The host's animation frames, where it has them: the desktop and the web. */
|
|
4
|
+
export const webFrame = globalThis as typeof globalThis & {
|
|
5
|
+
requestAnimationFrame?: (callback: () => void) => number;
|
|
6
|
+
cancelAnimationFrame?: (handle: number) => void;
|
|
7
|
+
};
|
|
8
|
+
|
|
9
|
+
/** The pointer's height in rows, to a fraction of one where the host reports it. */
|
|
10
|
+
export function pointerRow(event: ChartMouseEvent): number {
|
|
11
|
+
return typeof event.preciseY === "number" ? event.preciseY : event.y;
|
|
12
|
+
}
|
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
import type { ChartMouseEvent } from "../../core/pointer";
|
|
2
|
+
import type { CompositeCursorSource } from "../cursor-source";
|
|
3
|
+
import type { CompositeAxisValueFormatter } from "../format";
|
|
4
|
+
import type { CompositeNavigationFrame, CompositeViewportRange } from "../interactions";
|
|
5
|
+
import type { CompositeChartLevels } from "../levels";
|
|
6
|
+
import type { ChartDrawing, ChartToolKind, ChartToolSpan } from "../tools";
|
|
7
|
+
import type { CompositeAxisSide, CompositeChartColors, CompositeChartScene, CompositePanelScene } from "../types";
|
|
8
|
+
import type { KeyboardToolDrag } from "../use-composite-chart-keyboard";
|
|
9
|
+
import type { CompositeValueRange } from "../value-scale";
|
|
10
|
+
|
|
11
|
+
export interface CompositePanelSurfaceProps {
|
|
12
|
+
panel: CompositePanelScene;
|
|
13
|
+
/** The chart's scene, without its cursor: the crosshair comes from `cursor`. */
|
|
14
|
+
scene: CompositeChartScene;
|
|
15
|
+
cursor: CompositeCursorSource;
|
|
16
|
+
plotWidth: number;
|
|
17
|
+
leftAxisWidth: number;
|
|
18
|
+
rightAxisWidth: number;
|
|
19
|
+
axisGap: number;
|
|
20
|
+
colors: CompositeChartColors;
|
|
21
|
+
interactive: boolean;
|
|
22
|
+
/** False keeps the hover cursor but removes pan, zoom, and the tools. */
|
|
23
|
+
navigable: boolean;
|
|
24
|
+
formatAxisValue?: CompositeAxisValueFormatter;
|
|
25
|
+
remoteKind?: string;
|
|
26
|
+
viewport: CompositeViewportRange;
|
|
27
|
+
frame: CompositeNavigationFrame;
|
|
28
|
+
armedTool: ChartToolKind | null;
|
|
29
|
+
drawings: readonly ChartDrawing[];
|
|
30
|
+
selectedDrawingId: string | null;
|
|
31
|
+
drawColor: string;
|
|
32
|
+
onDraw: (drawing: ChartDrawing) => void;
|
|
33
|
+
onEditDrawing: (id: string, update: (drawing: ChartDrawing) => ChartDrawing) => void;
|
|
34
|
+
onSelectDrawing: (id: string | null) => void;
|
|
35
|
+
onActivate?: () => void;
|
|
36
|
+
onCursorDateChange: (date: Date | null) => void;
|
|
37
|
+
/** The cursor shown is another chart's, so the pointer's level is not part of it. */
|
|
38
|
+
sharedCursor: boolean;
|
|
39
|
+
/** Positive positions move toward older observations. A gesture supplies the frame and origin it started from. */
|
|
40
|
+
onPanViewport: (
|
|
41
|
+
deltaPositions: number,
|
|
42
|
+
gesture?: { frame: CompositeNavigationFrame; from: CompositeViewportRange },
|
|
43
|
+
) => void;
|
|
44
|
+
onZoomViewport: (zoomFactor: number, anchorRatio: number) => void;
|
|
45
|
+
onSetViewport: (range: CompositeViewportRange) => void;
|
|
46
|
+
onToolSpanChange: (span: ChartToolSpan | null) => void;
|
|
47
|
+
/** A press on the plot started (true) or stopped (false) dragging: a pan, a tool, a drawing or a level. */
|
|
48
|
+
onDragActiveChange?: (dragging: boolean) => void;
|
|
49
|
+
/** The tool being placed from the keyboard, when it lives in this panel. */
|
|
50
|
+
keyboardToolDrag: KeyboardToolDrag | null;
|
|
51
|
+
/** A press on the plot: the pointer takes over from a keyboard placement. */
|
|
52
|
+
onPointerPress: () => void;
|
|
53
|
+
showTextFallback: boolean;
|
|
54
|
+
/** Set while the owner is picking a bar: a press picks instead of panning. */
|
|
55
|
+
onPickTime?: (date: Date) => void;
|
|
56
|
+
/** Set while the owner is picking a price on the levels' series: a press picks the one under it. */
|
|
57
|
+
onPickPrice?: (value: number) => void;
|
|
58
|
+
/** The chart's levels when they draw on this panel. */
|
|
59
|
+
levels: CompositeChartLevels | null;
|
|
60
|
+
selectedLevelId: string | null;
|
|
61
|
+
onSelectLevel: (id: string | null) => void;
|
|
62
|
+
/** The value axes stretch and squeeze under a drag or the wheel, and a double click fits them again. */
|
|
63
|
+
valueScalable: boolean;
|
|
64
|
+
onSetValueScale: (panelId: string, side: CompositeAxisSide, key: string, range: CompositeValueRange) => void;
|
|
65
|
+
onResetValueScale: (panelId: string) => void;
|
|
66
|
+
/** A hairline on the line above this panel (desktop and web), as the chart's `panelRules` asks. */
|
|
67
|
+
ruleAbove?: boolean;
|
|
68
|
+
/** The line above this panel, which a drag moves (desktop and web): null for the top panel. */
|
|
69
|
+
dividerAbove?: { active: boolean; gestures: PanelDividerGestures } | null;
|
|
70
|
+
/** A double click on bare plot gives this panel the whole chart, or gives the others back. */
|
|
71
|
+
onToggleMaximized?: () => void;
|
|
72
|
+
}
|
|
73
|
+
|
|
74
|
+
interface PanelDividerGestures {
|
|
75
|
+
onMouseDown: (event: ChartMouseEvent) => void;
|
|
76
|
+
onMouseDrag: (event: ChartMouseEvent) => void;
|
|
77
|
+
onMouseUp: (event: ChartMouseEvent) => void;
|
|
78
|
+
onMouseDragEnd: (event: ChartMouseEvent) => void;
|
|
79
|
+
}
|