From fecbf8ed14ecb07f4c99dc21b6bdd668817ffb3d Mon Sep 17 00:00:00 2001 From: ntbang0901 <121003585+ntbang0901@users.noreply.github.com> Date: Sat, 14 Nov 2026 15:35:01 +0700 Subject: [PATCH] feat(debugger): evaluate watches while a JavaScript program runs (#3318) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit js-debug evaluates without suspending, so with Settings › Debugger › Evaluate watches while the program runs (off by default) the watches of a running Node.js program or page are evaluated once a second. Nothing is evaluated while the Debug tool window is hidden or the session is paused or ended, and a slow round isn't joined by another. Other debuggers keep showing "Not suspended". Co-authored-by: ntbang0901 <121003585+ntbang0901@users.noreply.github.com> --- crates/ide-core/src/workflow_settings.rs | 3 + crates/ide-dap/src/lib.rs | 4 + crates/ide-dap/src/tests.rs | 6 +- src/bindings.ts | 4 + .../debugger/__tests__/actions.test.ts | 1 + .../debugger/__tests__/liveWatches.test.ts | 144 ++++++++++++++++++ .../debugger/__tests__/toolWindow.test.tsx | 35 +++++ src/features/debugger/js/liveWatches.ts | 77 ++++++++++ src/features/debugger/ui/DebugToolWindow.tsx | 12 +- src/features/settings/pages/execution.tsx | 6 + src/platform/locales/text/en.json | 2 + src/platform/locales/text/zh.json | 4 +- src/platform/workflowSettings.ts | 3 + 13 files changed, 294 insertions(+), 7 deletions(-) create mode 100644 src/features/debugger/__tests__/liveWatches.test.ts create mode 100644 src/features/debugger/js/liveWatches.ts diff --git a/crates/ide-core/src/workflow_settings.rs b/crates/ide-core/src/workflow_settings.rs index 23e92b4fe..0bf63b23a 100644 --- a/crates/ide-core/src/workflow_settings.rs +++ b/crates/ide-core/src/workflow_settings.rs @@ -266,6 +266,8 @@ pub struct DebuggerSettings { pub inline_values: bool, /// Data Views: list variables by name instead of the adapter's order. pub sort_values: bool, + /// Data Views: evaluate watches while the program runs, where the debugger can (JavaScript). + pub live_watches: bool, pub value_tooltip: bool, /// While suspended, selecting an expression shows its value. pub value_tooltip_on_selection: bool, @@ -287,6 +289,7 @@ impl Default for DebuggerSettings { run_to_cursor_inlay: true, inline_values: true, sort_values: false, + live_watches: false, value_tooltip: true, value_tooltip_on_selection: true, value_tooltip_delay: 700, diff --git a/crates/ide-dap/src/lib.rs b/crates/ide-dap/src/lib.rs index 17e67a77e..9fa8e8693 100644 --- a/crates/ide-dap/src/lib.rs +++ b/crates/ide-dap/src/lib.rs @@ -140,6 +140,8 @@ pub struct DebugCapabilities { /// The session debugs a page in a browser: js-debug's requests for pages apply /// ([`DebugManager::js_set_custom_breakpoints`]). pub js_page: bool, + /// The adapter evaluates expressions while the program runs, without a stack frame. + pub live_evaluate: bool, } /// Result of [`DebugManager::redefine_classes`]. @@ -595,6 +597,7 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities { jvm_instances: false, jvm_heap: false, js_page: false, + live_evaluate: false, } } @@ -605,6 +608,7 @@ pub(crate) fn session_capabilities(session: &Session) -> DebugCapabilities { caps.jvm_instances = session.jvm_inspector.lock().is_some(); caps.jvm_heap = JVM_MEMORY_ADAPTERS.contains(&session.adapter.as_str()); caps.js_page = js_debug::is_page(session); + caps.live_evaluate = session.adapter == js_debug::ADAPTER; caps } diff --git a/crates/ide-dap/src/tests.rs b/crates/ide-dap/src/tests.rs index a9cc252ba..e02ba5c04 100644 --- a/crates/ide-dap/src/tests.rs +++ b/crates/ide-dap/src/tests.rs @@ -966,16 +966,16 @@ async fn a_browser_page_session_has_the_page_capability() { let h = harness(Script { start_debugging: true, ..Script::default() }); let browser = h.start(js_config("pwa-chrome")).await.unwrap(); let page = h.manager.capabilities(child_of(&h, browser).await).unwrap(); - assert!(page.js_page); + assert!(page.js_page && page.live_evaluate); assert!(!h.manager.capabilities(browser).unwrap().js_page, "the launch itself is not a page"); let node = h.start(js_config("pwa-node")).await.unwrap(); let process = h.manager.capabilities(child_of(&h, node).await).unwrap(); - assert!(!process.js_page); + assert!(!process.js_page && process.live_evaluate); let python = h.start(config()).await.unwrap(); let script = h.manager.capabilities(child_of(&h, python).await).unwrap(); - assert!(!script.js_page); + assert!(!script.js_page && !script.live_evaluate); } #[tokio::test] diff --git a/src/bindings.ts b/src/bindings.ts index b8f25fef0..0773ef92e 100644 --- a/src/bindings.ts +++ b/src/bindings.ts @@ -3965,6 +3965,8 @@ export type DebugCapabilities = { * ([`DebugManager::js_set_custom_breakpoints`]). */ jsPage: boolean, + /** The adapter evaluates expressions while the program runs, without a stack frame. */ + liveEvaluate: boolean, }; /** A completion the adapter offers for an expression (DAP `completions`). */ @@ -4016,6 +4018,8 @@ export type DebuggerSettings = { inlineValues?: boolean, /** Data Views: list variables by name instead of the adapter's order. */ sortValues?: boolean, + /** Data Views: evaluate watches while the program runs, where the debugger can (JavaScript). */ + liveWatches?: boolean, valueTooltip?: boolean, /** While suspended, selecting an expression shows its value. */ valueTooltipOnSelection?: boolean, diff --git a/src/features/debugger/__tests__/actions.test.ts b/src/features/debugger/__tests__/actions.test.ts index ef8b6c7ac..1e4951abc 100644 --- a/src/features/debugger/__tests__/actions.test.ts +++ b/src/features/debugger/__tests__/actions.test.ts @@ -107,6 +107,7 @@ const caps = (p: Partial = {}): DebugCapabilities => ({ jvmInstances: false, jvmHeap: false, jsPage: false, + liveEvaluate: false, ...p, }); diff --git a/src/features/debugger/__tests__/liveWatches.test.ts b/src/features/debugger/__tests__/liveWatches.test.ts new file mode 100644 index 000000000..417655809 --- /dev/null +++ b/src/features/debugger/__tests__/liveWatches.test.ts @@ -0,0 +1,144 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { act, renderHook } from "@testing-library/react"; + +type Answer = { status: "ok"; data: unknown } | { status: "error"; error: { kind: string; message: string } }; +const asked: Array<[number, number | null, string, string | null]> = []; +let answer: (expression: string) => Promise; +vi.mock("@/platform/ipc", async (orig) => { + const real = await orig(); + return { + ...real, + commands: { + ...real.commands, + debugEvaluateIn: (session: number, frame: number | null, expression: string, context: string | null) => { + asked.push([session, frame, expression, context]); + return answer(expression); + }, + }, + }; +}); + +const { useProject } = await import("@/platform/project"); +const { LIVE_WATCH_INTERVAL_MS, liveWatchesApply, useLiveWatches } = await import("../js/liveWatches"); +type Session = Parameters[0]; + +const session = (p: Record = {}): Session => + ({ id: 3, name: "page", status: "running", caps: { liveEvaluate: true }, ...p }) as Session; +const value = (text: string) => ({ status: "ok" as const, data: { value: text, variablesReference: 0 } }); +type Settings = ReturnType["settings"]; +const setLiveWatches = (on: boolean | null) => + useProject.setState({ settings: (on == null ? {} : { debugger: { liveWatches: on } }) as Settings }); +const settle = () => act(async () => void (await vi.advanceTimersByTimeAsync(0))); + +beforeEach(() => { + vi.useFakeTimers(); + asked.length = 0; + answer = (expression) => Promise.resolve(value(`<${expression}>`)); + setLiveWatches(true); +}); +afterEach(() => vi.useRealTimers()); + +describe("watches while the program runs", () => { + it("evaluates each watch without a frame while the session runs", async () => { + const { result } = renderHook(() => useLiveWatches(session(), ["a", "b"], true)); + await settle(); + expect(asked).toEqual([ + [3, null, "a", "watch"], + [3, null, "b", "watch"], + ]); + expect(result.current.map((r) => [r.expression, (r.result as { value: string } | null)?.value, r.error])).toEqual([ + ["a", "", null], + ["b", "", null], + ]); + }); + + it("refreshes every second and not faster", async () => { + expect(LIVE_WATCH_INTERVAL_MS).toBe(1000); + renderHook(() => useLiveWatches(session(), ["a"], true)); + await settle(); + expect(asked).toHaveLength(1); + await act(async () => void (await vi.advanceTimersByTimeAsync(999))); + expect(asked).toHaveLength(1); + await act(async () => void (await vi.advanceTimersByTimeAsync(1))); + expect(asked).toHaveLength(2); + }); + + it("skips a tick while the previous one is pending", async () => { + answer = () => new Promise(() => {}); + renderHook(() => useLiveWatches(session({ id: 90 }), ["slow"], true)); + await act(async () => void (await vi.advanceTimersByTimeAsync(3000))); + expect(asked).toHaveLength(1); + }); + + it("does not start a second round in a session when the watch list changes during a slow one", async () => { + let finish = () => {}; + answer = () => new Promise((resolve) => (finish = () => resolve(value("done")))); + const { rerender } = renderHook(({ list }) => useLiveWatches(session({ id: 91 }), list, true), { + initialProps: { list: ["slow"] }, + }); + await settle(); + rerender({ list: ["slow", "other"] }); + await act(async () => void (await vi.advanceTimersByTimeAsync(2000))); + expect(asked).toEqual([[91, null, "slow", "watch"]]); + // Once it has answered, the next tick asks for the list as it is now. + answer = (expression) => Promise.resolve(value(`<${expression}>`)); + finish(); + await act(async () => void (await vi.advanceTimersByTimeAsync(1000))); + expect(asked.slice(1).map((a) => a[2])).toEqual(["slow", "other"]); + }); + + it("is off until turned on in the settings", () => { + setLiveWatches(null); + expect(liveWatchesApply(session())).toBe(false); + setLiveWatches(true); + expect(liveWatchesApply(session())).toBe(true); + }); + + it("stops when hidden, paused, terminated, switched off or unsupported", async () => { + const quiet: Array<[Session, boolean]> = [ + [session(), false], + [session({ status: "paused" }), true], + [session({ status: "terminated" }), true], + [session({ caps: { liveEvaluate: false } }), true], + [session({ caps: null }), true], + [undefined, true], + ]; + for (const [s, visible] of quiet) { + const { result, unmount } = renderHook(() => useLiveWatches(s, ["a"], visible)); + await act(async () => void (await vi.advanceTimersByTimeAsync(2500))); + expect(result.current).toEqual([]); + unmount(); + } + setLiveWatches(false); + expect(liveWatchesApply(session())).toBe(false); + const { result } = renderHook(() => useLiveWatches(session(), ["a"], true)); + await act(async () => void (await vi.advanceTimersByTimeAsync(2500))); + expect(result.current).toEqual([]); + expect(asked).toEqual([]); + }); + + it("an evaluation error becomes the watch's error", async () => { + answer = () => + Promise.resolve({ status: "error", error: { kind: "internal", message: "ReferenceError: x is not defined" } }); + const { result } = renderHook(() => useLiveWatches(session(), ["x"], true)); + await settle(); + expect(result.current).toEqual([{ expression: "x", result: null, error: "ReferenceError: x is not defined" }]); + }); + + it("drops a late answer of another session", async () => { + let release: (a: Answer) => void = () => {}; + answer = () => new Promise((resolve) => (release = resolve)); + const { result, rerender } = renderHook(({ s }) => useLiveWatches(s, ["a"], true), { + initialProps: { s: session({ id: 3 }) }, + }); + await settle(); + answer = (expression) => Promise.resolve(value(`new ${expression}`)); + rerender({ s: session({ id: 4 }) }); + await settle(); + await act(async () => { + release(value("old")); + await vi.advanceTimersByTimeAsync(0); + }); + expect(result.current.map((r) => (r.result as { value: string } | null)?.value)).toEqual(["new a"]); + }); +}); diff --git a/src/features/debugger/__tests__/toolWindow.test.tsx b/src/features/debugger/__tests__/toolWindow.test.tsx index 52deb2527..0c5f2b04e 100644 --- a/src/features/debugger/__tests__/toolWindow.test.tsx +++ b/src/features/debugger/__tests__/toolWindow.test.tsx @@ -1,4 +1,5 @@ import { describe, expect, it, vi } from "vitest"; +import { useProject } from "@/platform/project"; import { act, fireEvent, render, screen, waitFor } from "@testing-library/react"; const adapterData = vi.hoisted(() => ({ @@ -67,6 +68,7 @@ vi.mock("@/workbench/confirmTerminate", () => ({ confirmTerminate })); import type { RunConfig } from "@/platform/ipc"; import { setLocale } from "@/platform/i18n"; +import { ToolWindowShownProvider } from "@/workbench/contributions"; import { handleDebugEvent, setVariableValue, useDebug, type DebugSession } from "../state"; import { DebugTabs, DebugToolWindow } from "../ui/DebugToolWindow"; import { DebuggerOverlays } from "../ui/Overlays"; @@ -389,4 +391,37 @@ describe("variables the adapter computes after the stop", () => { expect(useDebug.getState().variablesEpoch).toBe(1); expect(adapterData.memoryClasses).not.toHaveBeenCalled(); }); + + it("evaluates the watches of a running program only while the tool window is shown", async () => { + const caps = { liveEvaluate: true } as DebugSession["caps"]; + const running: DebugSession = { ...session, id: 5, status: "running", frames: [], selectedFrame: null, caps }; + useDebug.setState({ sessions: { 5: running }, active: 5, watches: ["count"] }); + const settings = useProject.getState().settings; + useProject.setState({ + settings: { debugger: { liveWatches: true } } as ReturnType["settings"], + }); + const watched = () => debugEvaluateIn.mock.calls.filter((c) => c[0] === 5 && c[3] === "watch"); + const shown = (value: boolean) => { + const view = render( + + + , + ); + fireEvent.click(screen.getByRole("tab", { name: "Threads & Variables" })); + return view; + }; + try { + debugEvaluateIn.mockClear(); + // A hidden tool window stays mounted. + const hidden = shown(false); + await tick(); + expect(watched()).toEqual([]); + hidden.unmount(); + shown(true); + await waitFor(() => expect(watched()).toEqual([[5, null, "count", "watch"]])); + } finally { + useDebug.setState({ watches: [] }); + useProject.setState({ settings }); + } + }); }); diff --git a/src/features/debugger/js/liveWatches.ts b/src/features/debugger/js/liveWatches.ts new file mode 100644 index 000000000..a0c08b39b --- /dev/null +++ b/src/features/debugger/js/liveWatches.ts @@ -0,0 +1,77 @@ +/** + * Watches of a program that is running: a debugger that evaluates without suspending + * (js-debug, `liveEvaluate`) is asked for them again and again, like a browser's live + * expressions. Elsewhere a watch has a value only while suspended. + */ +import { useEffect, useState } from "react"; +import { call, commands, type Variable } from "@/platform/ipc"; +import { workflowSettings } from "@/platform/workflowSettings"; +import type { DebugSession } from "../state"; + +/** How often the watches of a running program are evaluated again. */ +export const LIVE_WATCH_INTERVAL_MS = 1000; + +export interface LiveWatch { + expression: string; + result: Variable | null; + error: string | null; +} + +const NONE: LiveWatch[] = []; + +/** Sessions whose watches are being evaluated right now. */ +const evaluating = new Set(); + +/** Whether the watches of `session` are evaluated while it runs. */ +export function liveWatchesApply(session: DebugSession | undefined): boolean { + return ( + !!session && session.status === "running" && !!session.caps?.liveEvaluate && workflowSettings().debugger.liveWatches + ); +} + +/** + * The current values of `watches` in the running `session`, refreshed every + * `LIVE_WATCH_INTERVAL_MS` while `visible`; empty when they don't apply. A watch with a side + * effect has it again on each refresh. + */ +export function useLiveWatches( + session: DebugSession | undefined, + watches: readonly string[], + visible: boolean, +): LiveWatch[] { + const [data, setData] = useState<{ session: number; rows: LiveWatch[] }>({ session: -1, rows: NONE }); + const apply = visible && watches.length > 0 && liveWatchesApply(session); + const id = session?.id ?? -1; + const expressions = watches.join("\n"); + useEffect(() => { + if (!apply) return; + let current = true; + const refresh = async () => { + // A slow evaluation isn't joined by a second one, whichever watch list asked for it. + if (evaluating.has(id)) return; + evaluating.add(id); + const rows = await Promise.all( + expressions.split("\n").map(async (expression): Promise => { + try { + return { + expression, + result: await call(commands.debugEvaluateIn(id, null, expression, "watch")), + error: null, + }; + } catch (e) { + return { expression, result: null, error: e instanceof Error ? e.message : String(e) }; + } + }), + ); + evaluating.delete(id); + if (current) setData({ session: id, rows }); + }; + void refresh(); + const timer = window.setInterval(() => void refresh(), LIVE_WATCH_INTERVAL_MS); + return () => { + current = false; + window.clearInterval(timer); + }; + }, [apply, id, expressions]); + return apply && data.session === id ? data.rows : NONE; +} diff --git a/src/features/debugger/ui/DebugToolWindow.tsx b/src/features/debugger/ui/DebugToolWindow.tsx index 5ddc284a0..e7c2ba4a3 100644 --- a/src/features/debugger/ui/DebugToolWindow.tsx +++ b/src/features/debugger/ui/DebugToolWindow.tsx @@ -41,12 +41,14 @@ import { import { remoteWaitingNote } from "../remote"; import { sessionTabs } from "./sessionTabs"; import { stopNote } from "../js/eventBreakpoints"; +import { liveWatchesApply, useLiveWatches } from "../js/liveWatches"; import { MemoryView } from "../memory/MemoryView"; import { DebugConsole } from "./DebugConsole"; import { VariablesView, type VarRoot } from "./VariablesView"; import { useExpressionCompletion } from "./ExpressionCompletion"; import { sortVariables } from "../values"; import { workflowSettings } from "@/platform/workflowSettings"; +import { useToolWindowShown } from "@/workbench/contributions"; import styles from "./DebugToolWindow.module.css"; import { tx, useTx } from "@/platform/i18n"; @@ -436,6 +438,9 @@ function VariablesPane({ session }: { session: DebugSession }) { rows: [], }); const frame = session.status === "paused" ? session.selectedFrame : null; + const live = liveWatchesApply(session); + // A hidden tool window stays mounted: its watches must not go on running in the page. + const liveWatches = useLiveWatches(session, watches, useToolWindowShown()); // Same thread and stack depth across stops: compare like with like. const changeScope = `${session.id}:${session.selectedThread}:${session.frames.findIndex((f) => f.id === frame)}`; @@ -497,7 +502,8 @@ function VariablesPane({ session }: { session: DebugSession }) { variable: lastEval.result, error: lastEval.error, }); - const watchRows = watchData.frame === frame ? watchData.rows : []; + // While the program runs, a debugger that evaluates without suspending gives the values. + const watchRows = frame == null ? liveWatches : watchData.frame === frame ? watchData.rows : []; for (const w of watches) { const r = watchRows.find((x) => x.expression === w); out.push({ @@ -505,7 +511,7 @@ function VariablesPane({ session }: { session: DebugSession }) { kind: "watch", name: w, variable: r?.result ?? null, - error: frame == null ? "Not suspended" : (r?.error ?? null), + error: frame == null && !live ? "Not suspended" : (r?.error ?? null), }); } if (frame != null && scopeData.frame === frame) { @@ -533,7 +539,7 @@ function VariablesPane({ session }: { session: DebugSession }) { } } return out; - }, [lastEval, watches, watchData, scopeData, frame]); + }, [lastEval, watches, watchData, scopeData, frame, live, liveWatches]); const run = async () => { const e = expression.trim(); diff --git a/src/features/settings/pages/execution.tsx b/src/features/settings/pages/execution.tsx index 1dbe7e41a..834060337 100644 --- a/src/features/settings/pages/execution.tsx +++ b/src/features/settings/pages/execution.tsx @@ -305,6 +305,12 @@ export const EXECUTION_PAGES: PageSpec[] = [ hint: "Values of local variables are shown after the lines that use them while suspended.", }, { kind: "toggle", key: "debugger.sortValues", label: "Sort values alphabetically" }, + { + kind: "toggle", + key: "debugger.liveWatches", + label: "Evaluate watches while the program runs", + hint: "Where the debugger can do it without suspending (JavaScript). A watch with side effects runs again on each refresh.", + }, { kind: "toggle", key: "debugger.valueTooltip", diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.json index f67164fa9..d44fb767f 100644 --- a/src/platform/locales/text/en.json +++ b/src/platform/locales/text/en.json @@ -1647,6 +1647,8 @@ "Debug in Browser": "Debug in Browser", "Opens a URL in Chrome or Edge with the debugger attached (arg: the URL).": "Opens a URL in Chrome or Edge with the debugger attached (arg: the URL).", "Debugging a script that starts Vite, Next.js or another dev server also opens its page in Chrome or Edge with the debugger attached.": "Debugging a script that starts Vite, Next.js or another dev server also opens its page in Chrome or Edge with the debugger attached.", + "Evaluate watches while the program runs": "Evaluate watches while the program runs", + "Where the debugger can do it without suspending (JavaScript). A watch with side effects runs again on each refresh.": "Where the debugger can do it without suspending (JavaScript). A watch with side effects runs again on each refresh.", "Stash Selected Files…": "Stash Selected Files…", "Select the files to stash in the Commit view first": "Select the files to stash in the Commit view first" } diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json index 46a234aca..57d84d95c 100644 --- a/src/platform/locales/text/zh.json +++ b/src/platform/locales/text/zh.json @@ -8033,5 +8033,7 @@ "Debug a dev server's page in the browser": "在浏览器中调试开发服务器的页面", "Debug in Browser": "在浏览器中调试", "Opens a URL in Chrome or Edge with the debugger attached (arg: the URL).": "在 Chrome 或 Edge 中打开 URL 并附加调试器(参数:URL)。", - "Debugging a script that starts Vite, Next.js or another dev server also opens its page in Chrome or Edge with the debugger attached.": "调试启动 Vite、Next.js 等开发服务器的脚本时,同时在 Chrome 或 Edge 中打开其页面并附加调试器。" + "Debugging a script that starts Vite, Next.js or another dev server also opens its page in Chrome or Edge with the debugger attached.": "调试启动 Vite、Next.js 等开发服务器的脚本时,同时在 Chrome 或 Edge 中打开其页面并附加调试器。", + "Evaluate watches while the program runs": "程序运行时计算监视表达式", + "Where the debugger can do it without suspending (JavaScript). A watch with side effects runs again on each refresh.": "仅适用于无需暂停即可计算的调试器(JavaScript)。带副作用的监视表达式在每次刷新时都会再次执行。" } diff --git a/src/platform/workflowSettings.ts b/src/platform/workflowSettings.ts index dd9d377d1..b6d99f6f2 100644 --- a/src/platform/workflowSettings.ts +++ b/src/platform/workflowSettings.ts @@ -101,6 +101,7 @@ export interface DebuggerSettingsValid { runToCursorInlay: boolean; inlineValues: boolean; sortValues: boolean; + liveWatches: boolean; valueTooltip: boolean; valueTooltipOnSelection: boolean; valueTooltipDelay: number; @@ -293,6 +294,7 @@ export const DEFAULT_WORKFLOW: WorkflowSettings = { runToCursorInlay: true, inlineValues: true, sortValues: false, + liveWatches: false, valueTooltip: true, valueTooltipOnSelection: true, valueTooltipDelay: 700, @@ -451,6 +453,7 @@ export function validateDebugger(raw: unknown): DebuggerSettingsValid { runToCursorInlay: bool(v.runToCursorInlay, d.runToCursorInlay), inlineValues: bool(v.inlineValues, d.inlineValues), sortValues: bool(v.sortValues, d.sortValues), + liveWatches: bool(v.liveWatches, d.liveWatches), valueTooltip: bool(v.valueTooltip, d.valueTooltip), valueTooltipOnSelection: bool(v.valueTooltipOnSelection, d.valueTooltipOnSelection), valueTooltipDelay: num(v.valueTooltipDelay, d.valueTooltipDelay, WORKFLOW_LIMITS.tooltipDelay, true),