From 963402db1d90d0dab0d3547c43655ecfe2f42c19 Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Sat, 7 Nov 2026 21:00:36 +0800 Subject: [PATCH] fix: respect injected Stage ownership and scoped event sources Preserve caller-owned Stage rendering and lifecycle while binding scoped canvas/window input with matching cleanup. Track pointer-driven and programmatic dimension hover so cancellation emits leave once. Keep synchronous rate-limited callbacks on the original event and retain complete gesture payloads in delayed snapshots with VRender 1.1.14. Cancel pending callbacks when removing subscriptions or releasing the chart. Track subscriptions by handler identity so callback reuse across sources and Event instances preserves ownership during off, release and timer cancellation. Keep dimension-click and public chart cleanup consistent. Add event-chain regressions and deterministic browser interaction cases. --- .../unit/event/dimension-hover.test.ts | 273 ++++++++++++- .../__tests__/unit/event/event-delay.test.ts | 363 ++++++++++++++++++ .../unit/event/event-subscription.test.ts | 160 ++++++++ .../layout/incremental-measurement.test.ts | 34 ++ .../visual/cases/api/event-gesture-delay.mjs | 90 +++++ .../api/event-subscription-ownership.mjs | 111 ++++++ .../cases/api/event-throttle-propagation.mjs | 66 ++++ .../visual/cases/api/injected-stage.mjs | 213 ++++++++++ .../cases/api/state/dimension-index-leave.mjs | 57 +++ .../vchart/__tests__/visual/cases/index.mjs | 13 + packages/vchart/src/compile/compiler.ts | 65 +++- .../vchart/src/compile/interface/compiler.ts | 13 + packages/vchart/src/constant/event.ts | 1 + packages/vchart/src/core/vchart.ts | 2 +- packages/vchart/src/event/bubble.ts | 15 +- packages/vchart/src/event/event-dispatcher.ts | 55 ++- packages/vchart/src/event/event.ts | 52 +-- .../vchart/src/event/events/dimension/base.ts | 6 +- .../event/events/dimension/dimension-click.ts | 15 +- .../event/events/dimension/dimension-hover.ts | 60 ++- packages/vchart/src/event/interface.ts | 4 +- 21 files changed, 1538 insertions(+), 130 deletions(-) create mode 100644 packages/vchart/__tests__/unit/event/event-delay.test.ts create mode 100644 packages/vchart/__tests__/unit/event/event-subscription.test.ts create mode 100644 packages/vchart/__tests__/unit/layout/incremental-measurement.test.ts create mode 100644 packages/vchart/__tests__/visual/cases/api/event-gesture-delay.mjs create mode 100644 packages/vchart/__tests__/visual/cases/api/event-subscription-ownership.mjs create mode 100644 packages/vchart/__tests__/visual/cases/api/event-throttle-propagation.mjs create mode 100644 packages/vchart/__tests__/visual/cases/api/injected-stage.mjs create mode 100644 packages/vchart/__tests__/visual/cases/api/state/dimension-index-leave.mjs diff --git a/packages/vchart/__tests__/unit/event/dimension-hover.test.ts b/packages/vchart/__tests__/unit/event/dimension-hover.test.ts index 7dd111b0c1..64fee4e7f5 100644 --- a/packages/vchart/__tests__/unit/event/dimension-hover.test.ts +++ b/packages/vchart/__tests__/unit/event/dimension-hover.test.ts @@ -1,23 +1,262 @@ +import { EventEmitter } from '@visactor/vutils'; +import type { IStage } from '@visactor/vrender-core'; +import { Compiler } from '../../../src/compile/compiler'; +import { Factory } from '../../../src/core/factory'; +import type { VChart } from '../../../src/core/vchart'; +import { Event } from '../../../src/event/event'; +import { EventDispatcher } from '../../../src/event/event-dispatcher'; import { DimensionHoverEvent } from '../../../src/event/events/dimension/dimension-hover'; +import { DimensionClickEvent } from '../../../src/event/events/dimension/dimension-click'; +import type { IDimensionInfo } from '../../../src/event/events/dimension/interface'; +import type { RenderMode } from '../../../src/typings'; + +const createEvent = (canvas = new EventEmitter(), mode: RenderMode = 'desktop-browser', scoped = true) => { + const windowSource = new EventEmitter(); + const stageSource = new EventEmitter(); + const compiler = new Compiler(null, scoped ? { eventSource: { canvas, window: windowSource } } : {}); + compiler['_stage'] = { + addEventListener: stageSource.on.bind(stageSource), + removeEventListener: stageSource.off.bind(stageSource), + window: { addEventListener: canvas.on.bind(canvas), removeEventListener: canvas.off.bind(canvas) } + } as unknown as IStage; + const dimensionInfo: IDimensionInfo[] = [{ value: 'A', data: [] }]; + const chart = { + getOption: () => ({}), + getAllComponents: () => [{ specKey: 'axes', getScale: () => ({ type: 'band' }) }], + getModelOption: () => ({ + getDimensionInfo: () => dimensionInfo, + getDimensionInfoByValue: (_axis: unknown, value: unknown) => (value === 'A' ? dimensionInfo[0] : null) + }) + }; + const dispatcher = new EventDispatcher({ getChart: () => chart } as unknown as VChart, compiler); + const event = new Event(dispatcher, mode); + const move = () => stageSource.emit('pointermove', { viewX: 10, viewY: 20 }); + return { event, dispatcher, canvas, windowSource, stageSource, dimensionInfo, move }; +}; describe('[event] DimensionHoverEvent', () => { - test('unregisters every desktop event it registers', () => { - const eventDispatcher = { - register: jest.fn(), - unregister: jest.fn() - }; - const event = new DimensionHoverEvent(eventDispatcher as any, 'desktop-browser'); - - event.register('dimensionHover', { callback: jest.fn(), query: {} } as any); - event.unregister(); - - expect(eventDispatcher.unregister).toHaveBeenCalledWith('pointermove', { - query: null, - callback: expect.any(Function) - }); - expect(eventDispatcher.unregister).toHaveBeenCalledWith('pointerout', { - query: null, - callback: expect.any(Function) + const originalHover = Factory.getComposedEvent('dimensionHover'); + beforeAll(() => Factory.registerComposedEvent('dimensionHover', DimensionHoverEvent)); + afterAll(() => Factory.registerComposedEvent('dimensionHover', originalHover)); + + test.each(['pointerout', 'pointercancel'] as const)('programmatic activation is cleared by %s', type => { + const { event, dispatcher, canvas, dimensionInfo, move } = createEvent(); + const onHover = jest.fn(); + event.on('dimensionHover', onHover); + const hover = event.getComposedEventMap().get(onHover).event; + expect(hover.dispatch('A', {})).toEqual(dimensionInfo); + canvas.emit(type, { type }); + expect(onHover).toHaveBeenLastCalledWith(expect.objectContaining({ action: 'leave', dimensionInfo })); + canvas.emit(type, { type }); + expect(onHover).toHaveBeenCalledTimes(2); + move(); + expect(onHover).toHaveBeenLastCalledWith(expect.objectContaining({ action: 'enter', dimensionInfo })); + dispatcher.release(); + }); + + test('programmatic activation is committed before a callback cancels it', () => { + const { event, dispatcher, canvas } = createEvent(); + const onHover = jest.fn(params => { + if (params.action === 'enter') { + canvas.emit('pointercancel', { type: 'pointercancel' }); + } }); + event.on('dimensionHover', onHover); + event.getComposedEventMap().get(onHover).event.dispatch('A', {}); + expect(onHover.mock.calls.map(([params]) => params.action)).toEqual(['enter', 'leave']); + canvas.emit('pointerout', { type: 'pointerout' }); + expect(onHover).toHaveBeenCalledTimes(2); + dispatcher.release(); + }); + + test('an empty programmatic activation does not leave an active hover', () => { + const { event, dispatcher, canvas } = createEvent(); + const onHover = jest.fn(); + event.on('dimensionHover', onHover); + expect(event.getComposedEventMap().get(onHover).event.dispatch('missing', {})).toEqual([]); + canvas.emit('pointerout', { type: 'pointerout' }); + expect(onHover).toHaveBeenCalledTimes(1); + dispatcher.release(); + }); + + test('programmatic dimension click keeps its callback and return value', () => { + const { dispatcher, dimensionInfo } = createEvent(); + const click = new DimensionClickEvent(dispatcher, 'desktop-browser'); + const onClick = jest.fn(); + click.register('dimensionClick', { query: null, callback: onClick }); + expect(click.dispatch('A', {})).toEqual(dimensionInfo); + expect(onClick).toHaveBeenCalledWith({ action: 'enter', dimensionInfo }); + click.unregister(); + dispatcher.release(); + }); + + test('dimension click unregister cancels its delayed callback and retains other subscribers', async () => { + const { event, dispatcher, stageSource } = createEvent(); + const click = new DimensionClickEvent(dispatcher, 'desktop-browser'); + const onClick = jest.fn(); + const onOther = jest.fn(); + click.register('dimensionClick', { query: { debounce: 20 }, callback: onClick }); + event.on('pointertap', onOther); + try { + stageSource.emit('pointertap', { viewX: 10, viewY: 20 }); + click.unregister(); + click.unregister(); + stageSource.emit('pointertap', { viewX: 10, viewY: 20 }); + await new Promise(resolve => setTimeout(resolve, 40)); + expect(onClick).not.toHaveBeenCalled(); + expect(onOther).toHaveBeenCalledTimes(2); + event.release(); + expect(stageSource.listenerCount('pointertap')).toBe(0); + } finally { + click.unregister(); + event.release(); + dispatcher.release(); + } + }); + + test('scoped pointercancel reaches public listeners and clears hover without pointerout', () => { + const { event, dispatcher, canvas, dimensionInfo, move } = createEvent(); + const onCancel = jest.fn(); + const onHover = jest.fn(); + const cancel = { type: 'pointercancel', pointerId: 1 }; + + event.on('pointercancel', { source: 'canvas' }, onCancel); + event.on('dimensionHover', onHover); + move(); + expect(onHover).toHaveBeenLastCalledWith(expect.objectContaining({ action: 'enter', dimensionInfo })); + + canvas.emit('pointercancel', cancel); + expect(onCancel).toHaveBeenCalledWith(expect.objectContaining({ source: 'canvas', event: cancel })); + expect(onHover).toHaveBeenLastCalledWith(expect.objectContaining({ action: 'leave', dimensionInfo })); + + canvas.emit('pointercancel', cancel); + canvas.emit('pointerout', { type: 'pointerout' }); + expect(onHover).toHaveBeenCalledTimes(2); + + move(); + expect(onHover).toHaveBeenCalledTimes(3); + expect(onHover).toHaveBeenLastCalledWith(expect.objectContaining({ action: 'enter', dimensionInfo })); + + event.off('pointercancel', onCancel); + canvas.emit('pointercancel', cancel); + expect(onCancel).toHaveBeenCalledTimes(2); + expect(onHover).toHaveBeenLastCalledWith(expect.objectContaining({ action: 'leave', dimensionInfo })); + dispatcher.release(); + expect(canvas.listenerCount('pointercancel')).toBe(0); + }); + + test.each(['pointercancel', 'pointerout'] as const)('off dimensionHover removes the %s handler', type => { + const { event, dispatcher, canvas, move } = createEvent(); + const onHover = jest.fn(); + event.on('dimensionHover', onHover); + move(); + expect(onHover).toHaveBeenCalledTimes(1); + + event.off('dimensionHover', onHover); + canvas.emit(type, { type }); + move(); + expect(onHover).toHaveBeenCalledTimes(1); + expect(dispatcher['_canvasBubbles'].size).toBe(0); + expect(canvas.listenerCount(type)).toBe(0); + dispatcher.release(); + }); + + test.each([ + ['desktop-browser', true], + ['mobile-browser', true], + ['desktop-browser', false], + ['mobile-browser', false] + ] as const)('repeated on/off cleans handlers in %s, scoped=%s', (mode, scoped) => { + const { event, dispatcher, canvas, stageSource, move } = createEvent(new EventEmitter(), mode, scoped); + const onHover = jest.fn(); + for (let i = 0; i < 10; i++) { + event.on('dimensionHover', onHover); + move(); + event.off('dimensionHover', onHover); + expect(dispatcher['_canvasBubbles'].size).toBe(0); + expect(dispatcher['_viewBubbles'].size).toBe(0); + expect(canvas.eventNames()).toEqual([]); + expect(stageSource.eventNames()).toEqual([]); + } + expect(onHover).toHaveBeenCalledTimes(10); + event.on('dimensionHover', onHover); + move(); + canvas.emit('pointercancel', { type: 'pointercancel' }); + expect(onHover).toHaveBeenCalledTimes(12); + event.off('dimensionHover'); + expect(dispatcher['_canvasBubbles'].size).toBe(0); + dispatcher.release(); + }); + + test('off removes only its own hover handler and preserves another chart on the same source', () => { + const a = createEvent(); + const b = createEvent(a.canvas); + const onA = jest.fn(); + const onB = jest.fn(); + const onOtherChart = jest.fn(); + a.event.on('dimensionHover', onA); + a.event.on('dimensionHover', onB); + b.event.on('dimensionHover', onOtherChart); + a.move(); + b.move(); + + a.event.off('dimensionHover', onA); + expect(a.dispatcher['_canvasBubbles'].get('pointercancel').getCount()).toBe(1); + expect(a.dispatcher['_canvasBubbles'].get('pointerout').getCount()).toBe(1); + a.canvas.emit('pointercancel', { type: 'pointercancel' }); + expect(onA).toHaveBeenCalledTimes(1); + expect(onB).toHaveBeenCalledTimes(2); + expect(onOtherChart).toHaveBeenCalledTimes(2); + + a.event.release(); + expect(a.dispatcher['_canvasBubbles'].size).toBe(0); + expect(a.canvas.listenerCount('pointercancel')).toBe(1); + b.move(); + a.canvas.emit('pointerout', { type: 'pointerout' }); + expect(onA).toHaveBeenCalledTimes(1); + expect(onB).toHaveBeenCalledTimes(2); + expect(onOtherChart).toHaveBeenCalledTimes(4); + b.event.off('dimensionHover', onOtherChart); + expect(a.canvas.eventNames()).toEqual([]); + a.dispatcher.release(); + b.dispatcher.release(); + }); + + test.each(['canvas', 'window', 'chart'] as const)('public pointercancel connects and disconnects %s', source => { + const { event, dispatcher, canvas, windowSource, stageSource } = createEvent(); + const emitter = { canvas, window: windowSource, chart: stageSource }[source]; + const onCancel = jest.fn(); + event.on('pointercancel', { source }, onCancel); + emitter.emit('pointercancel', { type: 'pointercancel' }); + expect(onCancel).toHaveBeenCalledTimes(1); + expect(onCancel).toHaveBeenCalledWith(expect.objectContaining({ source })); + event.off('pointercancel', onCancel); + emitter.emit('pointercancel', { type: 'pointercancel' }); + expect(onCancel).toHaveBeenCalledTimes(1); + expect(emitter.listenerCount('pointercancel')).toBe(0); + dispatcher.release(); + }); + + test('off cancels pending debounced hover callbacks', async () => { + const { event, dispatcher, move } = createEvent(); + const onHover = jest.fn(); + const onActive = jest.fn(); + try { + event.on('dimensionHover', { debounce: 10 }, onHover); + const completed = new Promise(resolve => { + event.on('dimensionHover', { debounce: 10 }, params => { + onActive(params); + resolve(); + }); + }); + move(); + event.off('dimensionHover', onHover); + await completed; + expect(onActive).toHaveBeenCalledTimes(1); + expect(onHover).not.toHaveBeenCalled(); + } finally { + event.release(); + dispatcher.release(); + } }); }); diff --git a/packages/vchart/__tests__/unit/event/event-delay.test.ts b/packages/vchart/__tests__/unit/event/event-delay.test.ts new file mode 100644 index 0000000000..07bdfd9289 --- /dev/null +++ b/packages/vchart/__tests__/unit/event/event-delay.test.ts @@ -0,0 +1,363 @@ +import { EventEmitter } from '@visactor/vutils'; +import { Gesture } from '@visactor/vrender-kits'; +import { + EventManager, + FederatedPointerEvent, + FederatedWheelEvent, + type IStage, + type IEventTarget +} from '@visactor/vrender-core'; +import { Compiler } from '../../../src/compile/compiler'; +import type { VChart } from '../../../src/core/vchart'; +import { Event } from '../../../src/event/event'; +import { EventDispatcher } from '../../../src/event/event-dispatcher'; +import type { BaseEventParams } from '../../../src/event/interface'; + +const setup = () => { + const canvas = new EventEmitter(); + const windowSource = new EventEmitter(); + const chart = new EventEmitter(); + const manager = new EventManager(null, {}); + const compiler = new Compiler(null, { eventSource: { canvas, window: windowSource } }); + compiler['_stage'] = { + eventSystem: { manager }, + addEventListener: chart.on.bind(chart), + removeEventListener: chart.off.bind(chart) + } as unknown as IStage; + const dispatcher = new EventDispatcher({ getChart: (): null => null } as unknown as VChart, compiler); + const event = new Event(dispatcher, 'desktop-browser'); + return { event, dispatcher, manager, sources: { canvas, window: windowSource, chart } }; +}; + +describe('[event] delayed input', () => { + test.each(['canvas', 'window', 'chart'] as const)('debounce preserves pooled pointer data from %s', async source => { + const { event, dispatcher, sources } = setup(); + const input = new FederatedPointerEvent(); + input.type = 'pointerdown'; + input.pointerId = 1; + input.buttons = 1; + input.client.x = input.canvas.x = input.viewport.x = 200; + const completed = new Promise(resolve => { + event.on('pointerdown', { source, debounce: 20 }, params => resolve(params.event)); + }); + try { + sources[source].emit('pointerdown', input); + input.type = 'pointerup'; + input.buttons = 0; + input.client.x = input.canvas.x = input.viewport.x = 350; + const saved = await completed; + expect(saved).toMatchObject({ type: 'pointerdown', clientX: 200, canvasX: 200, viewX: 200, buttons: 1 }); + expect(saved).not.toBe(input); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test('throttle preserves the trailing pointer event', async () => { + const { event, dispatcher, sources } = setup(); + const input = new FederatedPointerEvent(); + input.pointerId = 1; + input.type = 'pointerdown'; + input.buttons = 1; + input.canvas.x = 200; + const calls: { type: string; x: number; buttons: number }[] = []; + const completed = new Promise(resolve => { + event.on('pointerdown', { source: 'canvas', throttle: 20 }, params => { + calls.push({ type: params.event.type, x: params.event.canvasX, buttons: params.event.buttons }); + if (calls.length === 2) { + resolve(); + } + }); + }); + try { + sources.canvas.emit('pointerdown', input); + input.canvas.x = 210; + sources.canvas.emit('pointerdown', input); + input.type = 'pointerup'; + input.buttons = 0; + input.canvas.x = 350; + await completed; + expect(calls).toEqual([ + { type: 'pointerdown', x: 200, buttons: 1 }, + { type: 'pointerdown', x: 210, buttons: 1 } + ]); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test.each([false, true])('delayed events retain payload and isolate pooled buffers (manager: %s)', async managed => { + const { event, dispatcher, manager, sources } = setup(); + const payloadKey = Symbol('payload'); + const payload = { value: 42 }; + const target = sources.chart as unknown as IEventTarget; + const input = Object.assign(new FederatedPointerEvent(managed ? manager : undefined), { + type: 'pointerdown', + pointerId: 1, + timeStamp: 123, + target, + currentTarget: target, + nativeEvent: {} as PointerEvent, + originalEvent: new FederatedPointerEvent(), + path: [target], + detailPath: [target], + customPayload: payload, + [payloadKey]: payload + }); + const coordinates = [ + 'layer', + 'page', + 'canvas', + 'viewport', + 'client', + 'movement', + 'offset', + 'global', + 'screen' + ] as const; + coordinates.forEach(key => Object.assign(input[key], { x: 200, y: 100 })); + const completed = new Promise(resolve => { + event.on('pointerdown', { source: 'canvas', debounce: 20 }, params => resolve(params.event)); + }); + try { + sources.canvas.emit('pointerdown', input); + coordinates.forEach(key => Object.assign(input[key], { x: 350, y: 250 })); + input.path.length = input.detailPath.length = 0; + input.customPayload = { value: 99 }; + const saved = await completed; + expect(saved).toBeInstanceOf(FederatedPointerEvent); + expect(saved.manager).toBe(input.manager); + expect(saved.timeStamp).toBe(123); + expect(saved.target).toBe(target); + expect(saved.currentTarget).toBe(target); + expect(saved.nativeEvent).toBe(input.nativeEvent); + expect(saved.originalEvent).toBe(input.originalEvent); + expect(saved.customPayload).toBe(payload); + expect(Reflect.get(saved, payloadKey)).toBe(payload); + expect(saved.path).toEqual([target]); + expect(saved.detailPath).toEqual([target]); + coordinates.forEach(key => expect(saved[key]).toEqual({ x: 200, y: 100 })); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test('throttle leading callback stops subsequent engine listeners on the original event', () => { + const { event, dispatcher, manager, sources } = setup(); + manager.rootTarget = sources.chart as unknown as EventManager['rootTarget']; + const input = new FederatedPointerEvent(manager); + input.type = 'pointerdown'; + input.pointerId = 1; + input.target = manager.rootTarget; + const received = jest.fn(params => params.event.stopImmediatePropagation()); + const host = jest.fn(); + event.on('pointerdown', { throttle: 20 }, received); + sources.chart.on('pointerdown', host); + try { + manager.dispatchEvent(input); + expect(received).toHaveBeenCalledTimes(1); + expect(received.mock.calls[0][0].event).toBe(input); + expect(input.propagationImmediatelyStopped).toBe(true); + expect(host).not.toHaveBeenCalled(); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test.each([ + ['stopPropagation', 'propagationStopped'], + ['preventDefault', 'defaultPrevented'] + ] as const)('throttle leading callback preserves %s on the original event', (method, flag) => { + const { event, dispatcher, sources } = setup(); + const input = new FederatedPointerEvent(); + input.pointerId = 1; + input.nativeEvent = {} as PointerEvent; + event.on('pointerdown', { source: 'canvas', throttle: 20 }, params => params.event[method]()); + try { + sources.canvas.emit('pointerdown', input); + expect(input[flag]).toBe(true); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test('debounce preserves wheel deltas and coordinates', async () => { + const { event, dispatcher, sources } = setup(); + const input = new FederatedWheelEvent(); + input.type = 'wheel'; + input.deltaMode = 0; + input.deltaX = 2; + input.deltaY = 10; + input.canvas.x = 200; + const completed = new Promise(resolve => { + event.on('wheel', { source: 'canvas', debounce: 20 }, params => resolve(params.event)); + }); + try { + sources.canvas.emit('wheel', input); + input.deltaX = 5; + input.deltaY = 20; + input.canvas.x = 350; + expect(await completed).toMatchObject({ type: 'wheel', deltaMode: 0, deltaX: 2, deltaY: 10, canvasX: 200 }); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test('synchronous subscribers keep the original event', () => { + const { event, dispatcher, sources } = setup(); + const input = new FederatedPointerEvent(); + input.pointerId = 1; + const received = jest.fn(); + event.on('pointerdown', { source: 'canvas' }, received); + sources.canvas.emit('pointerdown', input); + expect(received).toHaveBeenCalledWith(expect.objectContaining({ event: input })); + expect(received.mock.calls[0][0].event).toBe(input); + event.release(); + dispatcher.release(); + }); + + test('delayed non-pooled events keep their identity', async () => { + const { event, dispatcher, sources } = setup(); + const input = Object.freeze({ type: 'pointerdown', clientX: 200, buttons: 1 }); + const completed = new Promise(resolve => { + event.on('pointerdown', { source: 'canvas', debounce: 20 }, params => resolve(params.event)); + }); + try { + sources.canvas.emit('pointerdown', input); + expect(await completed).toBe(input); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test('delayed custom event parameters keep their shape', async () => { + const { event, dispatcher } = setup(); + const input = { source: 'chart' as const, datum: { x: 1 } }; + const completed = new Promise(resolve => { + event.on('custom', { debounce: 20 }, params => resolve(params)); + }); + try { + event.emit('custom', input); + expect(await completed).toStrictEqual(input); + } finally { + event.release(); + dispatcher.release(); + } + }); +}); + +describe('[event] gesture payload and delayed lifecycle', () => { + test('removing one callback preserves another pending callback on the same source', async () => { + const { event, dispatcher, sources } = setup(); + const removed = jest.fn(); + const input = new FederatedPointerEvent(); + input.pointerId = 1; + const completed = new Promise(resolve => { + event.on('pointerdown', { source: 'canvas', debounce: 20 }, removed); + event.on('pointerdown', { source: 'canvas', debounce: 20 }, resolve); + }); + try { + sources.canvas.emit('pointerdown', input); + event.off('pointerdown', removed); + await completed; + expect(removed).not.toHaveBeenCalled(); + } finally { + event.release(); + dispatcher.release(); + } + }); + + test.each(['debounce', 'throttle'] as const)('%s preserves real pinch payload through Compiler', async timing => { + const { event, dispatcher, manager, sources } = setup(); + const target = Object.assign(sources.chart, { + addEventListener: sources.chart.on.bind(sources.chart), + removeEventListener: sources.chart.off.bind(sources.chart) + }); + const gesture = new Gesture(target as unknown as IEventTarget); + // Advance the frame queue explicitly, without installing a rendering environment. + gesture['throttleTimer'] = 1; + let complete: () => void; + const completed = new Promise(resolve => (complete = resolve)); + const received = jest.fn((_params: BaseEventParams) => { + if (received.mock.calls.length === (timing === 'throttle' ? 2 : 1)) { + complete(); + } + }); + event.on('pinch', { [timing]: 20 }, received); + const pointer = (pointerId: number, x: number) => { + const input = new FederatedPointerEvent(manager); + input.pointerId = pointerId; + input.canvas.x = x; + return input; + }; + try { + sources.chart.emit('pointerdown', pointer(1, 0)); + sources.chart.emit('pointerdown', pointer(2, 10)); + sources.chart.emit('pointermove', pointer(2, 20)); + // Flush Gesture's frame queue through its real Stage listeners. + const flushGesture = () => { + gesture['emitThrottles'].splice(0).forEach(({ type, ev }: { type: string; ev: FederatedPointerEvent }) => { + gesture['emitEvent'](type, ev); + }); + }; + flushGesture(); + sources.chart.emit('pointermove', pointer(2, 30)); + flushGesture(); + await completed; + expect(received).toHaveBeenCalledTimes(timing === 'throttle' ? 2 : 1); + const last = received.mock.calls[received.mock.calls.length - 1][0].event; + expect(last).toMatchObject({ + scale: 3, + center: { x: 5, y: 0 }, + points: [ + { x: 0, y: 0 }, + { x: 30, y: 0 } + ] + }); + } finally { + gesture.release(); + gesture['reset'](); + event.release(); + dispatcher.release(); + } + }); + + test.each( + (['canvas', 'window', 'chart'] as const).flatMap(source => + (['debounce', 'throttle'] as const).flatMap(timing => + (['off', 'release', 'clear'] as const).map(operation => ({ source, timing, operation })) + ) + ) + )('%p cancels pending callbacks', async ({ source, timing, operation }) => { + const { event, dispatcher, sources } = setup(); + const callback = jest.fn(); + event.on('pointerdown', { source, [timing]: 20 }, callback); + const input = new FederatedPointerEvent(); + input.pointerId = 1; + sources[source].emit('pointerdown', input); + if (timing === 'throttle') { + expect(callback).toHaveBeenCalledTimes(1); + sources[source].emit('pointerdown', input); + callback.mockClear(); + } + if (operation === 'off') { + event.off('pointerdown'); + } else if (operation === 'release') { + event.release(); + } else { + dispatcher.clear(); + } + sources[source].emit('pointerdown', input); + await new Promise(resolve => setTimeout(resolve, 40)); + expect(callback).not.toHaveBeenCalled(); + event.release(); + dispatcher.release(); + }); +}); diff --git a/packages/vchart/__tests__/unit/event/event-subscription.test.ts b/packages/vchart/__tests__/unit/event/event-subscription.test.ts new file mode 100644 index 0000000000..a943b2ad57 --- /dev/null +++ b/packages/vchart/__tests__/unit/event/event-subscription.test.ts @@ -0,0 +1,160 @@ +import { EventEmitter } from '@visactor/vutils'; +import type { IStage } from '@visactor/vrender-core'; +import { Compiler } from '../../../src/compile/compiler'; +import type { VChart } from '../../../src/core/vchart'; +import { Event } from '../../../src/event/event'; +import { EventDispatcher } from '../../../src/event/event-dispatcher'; +import type { BaseEventParams } from '../../../src/event/interface'; + +const sourceNames = ['chart', 'canvas', 'window'] as const; +const setup = () => { + const sources = { chart: new EventEmitter(), canvas: new EventEmitter(), window: new EventEmitter() }; + const compiler = new Compiler(null, { eventSource: sources }); + compiler['_stage'] = { + addEventListener: sources.chart.on.bind(sources.chart), + removeEventListener: sources.chart.off.bind(sources.chart) + } as unknown as IStage; + const dispatcher = new EventDispatcher({ getChart: (): null => null } as unknown as VChart, compiler); + const first = new Event(dispatcher, 'desktop-browser'); + const other = new Event(dispatcher, 'desktop-browser'); + const emit = (owner = 'both') => { + sourceNames.forEach(source => sources[source].emit('pointermove', { type: 'pointermove', owner })); + }; + const release = () => { + first.release(); + other.release(); + dispatcher.release(); + }; + return { first, other, sources, dispatcher, emit, release }; +}; + +describe('[event] subscription ownership', () => { + test.each(['off', 'callback', 'release'] as const)( + '%s removes all owned sources and retains other instances', + operation => { + const { first, other, sources, emit, release } = setup(); + const callback = jest.fn(); + sourceNames.forEach(source => { + first.on('pointermove', { source, filter: p => p.event.owner !== 'other' }, callback); + other.on('pointermove', { source, filter: p => p.event.owner !== 'first' }, callback); + }); + try { + emit(); + expect(callback).toHaveBeenCalledTimes(6); + callback.mockClear(); + if (operation === 'off') { + first.off('pointermove'); + } else if (operation === 'callback') { + first.off('pointermove', callback); + } else { + first.release(); + } + first.release(); + emit('first'); + expect(callback).not.toHaveBeenCalled(); + emit('other'); + expect(callback.mock.calls.map(([params]) => params.source)).toEqual(sourceNames); + other.release(); + sourceNames.forEach(source => expect(sources[source].listenerCount('pointermove')).toBe(0)); + } finally { + release(); + } + } + ); + + test.each(sourceNames)('off with explicit %s source preserves the other sources', source => { + const { first, emit, release } = setup(); + const callback = jest.fn(); + sourceNames.forEach(name => first.on('pointermove', { source: name }, callback)); + try { + first.off('pointermove', { source }, callback); + first.off('pointermove', { source }, callback); + emit(); + expect(callback.mock.calls.map(([params]) => params.source)).toEqual(sourceNames.filter(name => name !== source)); + callback.mockClear(); + first.release(); + emit(); + expect(callback).not.toHaveBeenCalled(); + } finally { + release(); + } + }); + + test('callback removal retains unrelated callbacks and event types', () => { + const { first, sources, emit, release } = setup(); + const removed = jest.fn(); + const retained = jest.fn(); + sourceNames.forEach(source => first.on('pointermove', { source }, removed)); + first.on('pointermove', retained); + first.on('pointerdown', removed); + try { + first.off('pointermove', removed); + emit(); + expect(removed).not.toHaveBeenCalled(); + expect(retained).toHaveBeenCalledTimes(1); + sources.chart.emit('pointerdown', { type: 'pointerdown' }); + expect(removed).toHaveBeenCalledTimes(1); + } finally { + release(); + } + }); + + test('same callback at different bubble levels is fully removed', () => { + const { first, dispatcher, emit, release } = setup(); + const callback = jest.fn(); + first.on('pointermove', { level: 'model' }, callback); + first.on('pointermove', callback); + try { + dispatcher.dispatch('pointermove', { + source: 'chart', + model: {}, + event: { type: 'pointermove' } + } as BaseEventParams); + expect(callback).toHaveBeenCalledTimes(2); + callback.mockClear(); + first.off('pointermove', callback); + emit(); + expect(callback).not.toHaveBeenCalled(); + } finally { + release(); + } + }); + + test.each( + (['debounce', 'throttle'] as const).flatMap(timing => + (['off', 'release', 'clear'] as const).map(operation => ({ timing, operation })) + ) + )('%p cancels only the removed subscriptions', async ({ timing, operation }) => { + const { first, other, dispatcher, sources, emit, release } = setup(); + const callback = jest.fn(); + sourceNames.forEach(source => { + first.on('pointermove', { source, [timing]: 20, filter: p => p.event.owner !== 'other' }, callback); + other.on('pointermove', { source, [timing]: 20, filter: p => p.event.owner !== 'first' }, callback); + }); + try { + emit(); + if (timing === 'throttle') { + expect(callback).toHaveBeenCalledTimes(6); + callback.mockClear(); + emit(); + } + if (operation === 'off') { + first.off('pointermove'); + } else if (operation === 'release') { + first.release(); + } else { + dispatcher.clear(); + } + await new Promise(resolve => setTimeout(resolve, 40)); + expect(callback.mock.calls.map(([params]) => params.source)).toEqual(operation === 'clear' ? [] : sourceNames); + callback.mockClear(); + emit('first'); + await new Promise(resolve => setTimeout(resolve, 40)); + expect(callback).not.toHaveBeenCalled(); + other.release(); + sourceNames.forEach(source => expect(sources[source].listenerCount('pointermove')).toBe(0)); + } finally { + release(); + } + }); +}); diff --git a/packages/vchart/__tests__/unit/layout/incremental-measurement.test.ts b/packages/vchart/__tests__/unit/layout/incremental-measurement.test.ts new file mode 100644 index 0000000000..cfac96dca5 --- /dev/null +++ b/packages/vchart/__tests__/unit/layout/incremental-measurement.test.ts @@ -0,0 +1,34 @@ +import { LayoutItem } from '../../../src/layout/layout-item'; +import { getItemLayoutWithTag } from '../../../src/layout/util'; +import type { Layout } from '../../../src/layout/base-layout'; +import type { ILayoutRect } from '../../../src/typings/layout'; + +// Title measurement temporarily installs the available space as its layout rect. +// A later incremental pass must reuse the measured size, not that temporary space. +describe('incremental layout after measurement', () => { + test.each(['top', 'left'] as const)('retains measured dimensions for a %s item', orient => { + const measured = { width: 100, height: 20 }; + const item = new LayoutItem( + { + getBoundsInRect: (available: ILayoutRect) => { + item.setLayoutRect(available); + return { x1: 0, y1: 0, x2: measured.width, y2: measured.height }; + } + } as any, + { layoutType: 'normal', layoutLevel: 1, layoutOrient: orient } + ); + item.setLayoutRect(measured); + const layout = { + getItemComputeLayoutRect: () => ({ width: 700, height: 400 }) + } as unknown as Layout; + const recompute = { recomputeWidth: false, recomputeHeight: false }; + const first = getItemLayoutWithTag(item, layout, recompute); + expect(first.rect).toEqual(measured); + expect(first.layoutTag).toBe(false); + expect(recompute).toEqual({ recomputeWidth: false, recomputeHeight: false }); + expect(item.getLayoutRect()).toEqual(measured); + + item.clearWillLayoutTag(); + expect(getItemLayoutWithTag(item, layout, recompute).rect).toEqual(measured); + }); +}); diff --git a/packages/vchart/__tests__/visual/cases/api/event-gesture-delay.mjs b/packages/vchart/__tests__/visual/cases/api/event-gesture-delay.mjs new file mode 100644 index 0000000000..4e63dc606b --- /dev/null +++ b/packages/vchart/__tests__/visual/cases/api/event-gesture-delay.mjs @@ -0,0 +1,90 @@ +/** + * 验证目的:延迟手势回调保留完整 pinch 载荷,缩放回调能够实际更新图表数据。 + * 图表类型:bar;固定数据,关闭动画和 tooltip。 + * 关键配置:gestureConfig、pinch debounce 和 throttle 尾调用。 + * 场景条件:Chromium 原生双指输入,先放大到 1.5 倍,再放大到 2 倍。 + * 最终检查:scale、center、points 完整,柱数据由 10 更新为 20;截图检查更新后的图表。 + * 覆盖边界:不替代移动真机验证;同步传播及注入事件池另有独立用例。 + */ +export default { + createSpec() { + return { + type: 'bar', + width: 400, + height: 300, + autoFit: false, + animation: false, + xField: 'x', + yField: 'y', + data: { id: 'data', values: [{ x: 'A', y: 10 }] }, + tooltip: { visible: false } + }; + }, + async exercise(page) { + const session = await page.context().newCDPSession(page); + try { + await session.send('Emulation.setTouchEmulationEnabled', { enabled: true, maxTouchPoints: 2 }); + await page.evaluate(() => { + const spec = window.__visualChart.getSpec(); + window.__visualChart.release(); + const chart = new window.VChart.default(spec, { + dom: 'chart', + autoFit: false, + animation: false, + gestureConfig: {} + }); + window.__visualChart = chart; + chart.renderSync(); + chart.getCanvas().style.touchAction = 'none'; + const state = { syncCalls: 0, throttleCalls: 0 }; + const payload = event => ({ scale: event.scale, center: event.center, points: event.points }); + chart.on('pinch', () => state.syncCalls++); + chart.on('pinch', { debounce: 1000 }, ({ event }) => { + state.debounced = payload(event); + chart.updateData('data', [{ x: 'A', y: event.scale * 10 }]); + }); + chart.on('pinch', { throttle: 1000 }, ({ event }) => { + state.throttleCalls++; + state.throttled = payload(event); + }); + window.__gestureDelay = state; + }); + const points = x => [ + { x: 100, y: 180, id: 1 }, + { x, y: 180, id: 2 } + ]; + await session.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: points(200) }); + await session.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: points(250) }); + await page.waitForFunction(() => window.__gestureDelay.syncCalls === 1); + await session.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: points(300) }); + await page.waitForFunction(() => window.__gestureDelay.syncCalls === 2); + await session.send('Input.dispatchTouchEvent', { type: 'touchEnd', touchPoints: [] }); + await page.waitForFunction(() => window.__gestureDelay.debounced && window.__gestureDelay.throttleCalls === 2); + await page.evaluate(() => window.__visualChart.off('pinch')); + } finally { + await session.detach(); + } + }, + async verify(page) { + await page.evaluate(async () => { + const state = window.__gestureDelay; + const expected = JSON.stringify({ + scale: 2, + center: { x: 150, y: 180 }, + points: [ + { x: 100, y: 180 }, + { x: 300, y: 180 } + ] + }); + const data = window.__visualChart.getChart().getAllSeries()[0].getViewData().latestData; + if ( + JSON.stringify(state?.debounced) !== expected || + JSON.stringify(state?.throttled) !== expected || + data[0].y !== 20 + ) { + const { assertionError } = await import('/suite/assertions.mjs'); + throw assertionError('延迟 pinch 载荷丢失或图表数据未更新:' + JSON.stringify({ state, value: data[0].y })); + } + }); + } +}; diff --git a/packages/vchart/__tests__/visual/cases/api/event-subscription-ownership.mjs b/packages/vchart/__tests__/visual/cases/api/event-subscription-ownership.mjs new file mode 100644 index 0000000000..fc3bbfce4d --- /dev/null +++ b/packages/vchart/__tests__/visual/cases/api/event-subscription-ownership.mjs @@ -0,0 +1,111 @@ +/** + * 验证目的:复用同一回调的跨 source 订阅完整解绑,并保留其他 Event 实例的监听。 + * 图表类型:bar;固定数据,关闭动画和 tooltip。 + * 场景条件:两个 Event 实例共享真实 Dispatcher;Chromium 鼠标输入同时触发 chart/canvas。 + * 最终检查:chart.off、Event.off、指定 source 解绑和 release 隔离;保留的回调将柱数据改为 20。 + * 覆盖边界:延迟回调取消及 window source 由真实事件链单测覆盖。 + */ +export default { + createSpec() { + return { + type: 'bar', + width: 400, + height: 300, + autoFit: false, + animation: false, + xField: 'x', + yField: 'y', + data: { id: 'data', values: [{ x: 'A', y: 10 }] }, + tooltip: { visible: false } + }; + }, + async exercise(page) { + const point = await page.evaluate(() => { + const chart = window.__visualChart; + const sibling = new window.VChart.Event(chart.event._eventDispatcher, 'desktop-browser'); + const state = { sibling, phase: 'before', calls: {}, observers: {}, userEntries: -1 }; + const callback = params => { + (state.calls[state.phase] ??= []).push(params.source); + }; + state.callback = callback; + for (const source of ['chart', 'canvas']) { + chart.on('pointermove', { source }, callback); + sibling.on('pointermove', { source }, callback); + } + sibling.on('pointermove', () => { + state.observers[state.phase] = (state.observers[state.phase] ?? 0) + 1; + if (state.phase === 'afterDirectOff') chart.updateData('data', [{ x: 'A', y: 20 }]); + }); + window.__subscriptionOwnership = state; + const box = chart.getCanvas().getBoundingClientRect(); + return { x: box.x + box.width / 2, y: box.y + box.height / 2 }; + }); + try { + await page.mouse.move(point.x, point.y); + await page.evaluate(() => { + const chart = window.__visualChart; + const s = window.__subscriptionOwnership; + chart.off('pointermove', s.callback); + s.userEntries = chart._userEvents.filter(e => e.handler === s.callback).length; + s.phase = 'afterPublicOff'; + }); + await page.mouse.move(point.x + 2, point.y); + await page.evaluate(() => { + const s = window.__subscriptionOwnership; + for (const source of ['chart', 'canvas']) window.__visualChart.event.on('pointermove', { source }, s.callback); + s.phase = 'beforeDirectOff'; + }); + await page.mouse.move(point.x + 4, point.y); + await page.evaluate(() => { + window.__visualChart.event.off('pointermove'); + window.__subscriptionOwnership.phase = 'afterDirectOff'; + }); + await page.mouse.move(point.x + 6, point.y); + await page.evaluate(() => { + const s = window.__subscriptionOwnership; + s.sibling.off('pointermove', { source: 'chart' }, s.callback); + s.phase = 'afterSourceOff'; + }); + await page.mouse.move(point.x + 8, point.y); + await page.evaluate(() => { + const s = window.__subscriptionOwnership; + s.sibling.release(); + s.phase = 'afterRelease'; + }); + await page.mouse.move(point.x + 10, point.y); + await page.mouse.move(900, 700); + } finally { + await page.evaluate(() => window.__subscriptionOwnership.sibling.release()); + } + }, + async verify(page) { + await page.evaluate(async () => { + const s = window.__subscriptionOwnership; + const expected = { + before: ['canvas', 'canvas', 'chart', 'chart'], + afterPublicOff: ['canvas', 'chart'], + beforeDirectOff: ['canvas', 'canvas', 'chart', 'chart'], + afterDirectOff: ['canvas', 'chart'], + afterSourceOff: ['canvas'], + afterRelease: [] + }; + const data = window.__visualChart.getChart().getAllSeries()[0].getViewData().latestData; + if ( + !s || + s.userEntries !== 0 || + data[0].y !== 20 || + Object.entries(expected).some( + ([phase, sources]) => + JSON.stringify([...(s.calls[phase] ?? [])].sort()) !== JSON.stringify(sources) || + (s.observers[phase] ?? 0) !== (phase === 'afterRelease' ? 0 : 1) + ) + ) { + const { assertionError } = await import('/suite/assertions.mjs'); + throw assertionError( + '订阅解绑或实例隔离异常:' + + JSON.stringify({ calls: s?.calls, observers: s?.observers, userEntries: s?.userEntries, value: data[0].y }) + ); + } + }); + } +}; diff --git a/packages/vchart/__tests__/visual/cases/api/event-throttle-propagation.mjs b/packages/vchart/__tests__/visual/cases/api/event-throttle-propagation.mjs new file mode 100644 index 0000000000..ddf5092f1b --- /dev/null +++ b/packages/vchart/__tests__/visual/cases/api/event-throttle-propagation.mjs @@ -0,0 +1,66 @@ +/** + * 验证目的:throttle 首次同步回调仍能通过原事件拦截后续 Stage 监听器。 + * 图表类型:bar;固定数据,关闭动画和 tooltip。 + * 关键配置:公开 pointerdown 订阅设置 throttle: 20,调用 stopImmediatePropagation。 + * 场景条件:真实 Chromium 点击;Stage capture 先记录原事件,宿主监听器在图表订阅后注册。 + * 最终检查:图表回调同步收到原事件一次,后续宿主回调为零;截图检查固定图表。 + * 覆盖边界:延迟尾调用的数据保存另由 injected-stage 和单元测试覆盖。 + */ +export default { + createSpec() { + return { + type: 'bar', + width: 400, + height: 300, + autoFit: false, + animation: false, + xField: 'x', + yField: 'y', + data: { id: 'data', values: [{ x: 'A', y: 10 }] }, + tooltip: { visible: false } + }; + }, + async exercise(page) { + const point = await page.evaluate(() => { + const chart = window.__visualChart; + const stage = chart.getStage(); + const state = { chartCalls: 0, hostCalls: 0, originalPreserved: false }; + state.onCapture = event => { + state.original = event; + }; + state.onChart = params => { + state.chartCalls++; + state.originalPreserved = params.event === state.original; + params.event.stopImmediatePropagation(); + }; + state.onHost = () => state.hostCalls++; + stage.addEventListener('pointerdown', state.onCapture, { capture: true }); + chart.on('pointerdown', { throttle: 20 }, state.onChart); + stage.addEventListener('pointerdown', state.onHost); + window.__throttlePropagation = state; + const box = chart.getCanvas().getBoundingClientRect(); + return { x: box.x + box.width / 2, y: box.y + box.height / 2 }; + }); + await page.mouse.click(point.x, point.y); + await page.evaluate(() => { + const chart = window.__visualChart; + const stage = chart.getStage(); + const state = window.__throttlePropagation; + chart.off('pointerdown', state.onChart); + stage.removeEventListener('pointerdown', state.onCapture, { capture: true }); + stage.removeEventListener('pointerdown', state.onHost); + }); + await page.mouse.move(900, 700); + }, + async verify(page) { + await page.evaluate(async () => { + const { chartCalls, hostCalls, originalPreserved } = window.__throttlePropagation; + if (chartCalls !== 1 || hostCalls !== 0 || !originalPreserved) { + const { assertionError } = await import('/suite/assertions.mjs'); + throw assertionError( + 'throttle 同步回调未保留原事件的传播控制:' + JSON.stringify({ chartCalls, hostCalls, originalPreserved }) + ); + } + }); + } +}; diff --git a/packages/vchart/__tests__/visual/cases/api/injected-stage.mjs b/packages/vchart/__tests__/visual/cases/api/injected-stage.mjs new file mode 100644 index 0000000000..2b9e08d7fb --- /dev/null +++ b/packages/vchart/__tests__/visual/cases/api/injected-stage.mjs @@ -0,0 +1,213 @@ +/** + * 验证目的:调用方提供 Stage 时保留调度权、执行图表绘制准备,并正确解绑注入的事件源。 + * 图表类型:bar;固定默认 crosshair 验证 beforeRender 的实际图元结果。 + * 场景条件:复用一个真实 Stage,暂停原生事件监听后 canvas/window 订阅不能绕过该输入源。 + * 最终检查:默认 crosshair 可见;取消与重入生效;公开 off 后不再通知;释放不释放 Stage 或遗留订阅。 + * 覆盖边界:不验证宿主坐标映射、冻结窗格或原生 HTML Tooltip 定位。 + */ +export default { + createSpec() { + return { + type: 'bar', + width: 800, + height: 600, + autoFit: false, + animation: false, + xField: ['x', 's'], + seriesField: 's', + yField: 'y', + data: { + id: 'data', + values: [ + { x: 'A', s: 'Gold', y: 9 }, + { x: 'A', s: 'Silver', y: 5 }, + { x: 'B', s: 'Gold', y: 7 }, + { x: 'B', s: 'Silver', y: 4 } + ] + }, + tooltip: { visible: false } + }; + }, + async exercise(page) { + const point = await page.evaluate(() => { + const owner = window.__visualChart; + const stage = owner.getStage(); + let subscriptions = 0; + const wrap = source => ({ + on(type, listener) { + subscriptions++; + source.on(type, listener); + }, + off(type, listener) { + subscriptions--; + source.off(type, listener); + } + }); + const source = { canvas: wrap(stage.eventSystem.input.canvas), window: wrap(stage.eventSystem.input.window) }; + const count = () => subscriptions; + const initialListeners = count(); + const initialChildren = stage.defaultLayer.childrenCount; + const initialHooks = stage.hooks.beforeRender.taps.length; + stage.disableIncrementalAutoRender(); + const chart = new window.VChart.default( + { + ...owner.getSpec(), + tooltip: { visible: true, renderMode: 'html', throttleInterval: 0, transitionDuration: 0 }, + crosshair: { xField: { visible: true, defaultSelect: { axisIndex: 0, datum: 'A' }, line: { type: 'rect' } } } + }, + { stage, eventSource: source, autoFit: false, animation: false, poptip: false } + ); + chart.renderSync(); + stage.render(); + const keepsScheduling = stage.pluginService.findPluginsByName('IncrementalAutoRenderPlugin').length === 0; + const rect = stage.find(g => g.name === 'crosshair-rect', true); + const crosshairVisible = + !!rect && rect.attribute.visible !== false && rect.attribute.width > 0 && rect.attribute.height > 0; + const counts = { canvas: 0, window: 0, cancel: 0, rawCancel: 0 }; + const dimensions = []; + const onDimensionHover = p => dimensions.push(p.action); + const onRawCancel = () => counts.rawCancel++; + stage.eventSystem.input.canvas.on('pointercancel', onRawCancel); + chart.on('dimensionHover', onDimensionHover); + chart.on('pointermove', { source: 'canvas' }, () => counts.canvas++); + chart.on('pointerup', { source: 'window' }, () => counts.window++); + chart.on('pointercancel', { source: 'canvas' }, () => counts.cancel++); + window.__injectedStage = { + chart, + stage, + count, + counts, + dimensions, + onDimensionHover, + onRawCancel, + initialListeners, + initialChildren, + initialHooks, + crosshairVisible, + keepsScheduling, + target: stage.eventSystem.domElement + }; + stage.eventSystem.setTargetElement(null); + const box = owner.getCanvas().getBoundingClientRect(); + const bars = chart + .getChart() + .getAllMarks() + .flatMap(mark => mark.getGraphics?.() || []) + .filter(g => g.type === 'rect' && g.globalAABBBounds.height() > 2) + .sort((a, b) => a.globalAABBBounds.x1 - b.globalAABBBounds.x1); + const center = g => ({ + x: box.x + (g.globalAABBBounds.x1 + g.globalAABBBounds.x2) / 2, + y: box.y + (g.globalAABBBounds.y1 + g.globalAABBBounds.y2) / 2 + }); + return { ...center(bars[0]), sibling: center(bars[1]) }; + }); + await page.mouse.click(point.x, point.y); + await page.evaluate(() => { + const state = window.__injectedStage; + state.blocked = { ...state.counts }; + state.stage.eventSystem.setTargetElement(state.target); + }); + await page.mouse.move(point.x + 1, point.y + 1); + await page.mouse.click(point.x + 1, point.y + 1); + await page.mouse.move(point.sibling.x, point.sibling.y); + await page.waitForFunction(() => window.__injectedStage.chart.getTooltipHandler()?.isTooltipShown()); + await page.evaluate(() => { + const state = window.__injectedStage; + state.delayed = {}; + state.delayedReady = new Promise(resolve => { + let pending = 2; + const capture = key => params => { + const event = params.event; + state.delayed[key] = { type: event.type, x: event.clientX, buttons: event.buttons }; + if (--pending === 0) resolve(); + }; + state.chart.on('pointerdown', { source: 'canvas', debounce: 200 }, capture('injected')); + window.__visualChart.on('pointerdown', { source: 'canvas', debounce: 200 }, capture('dom')); + }); + }); + // 延迟回调必须保留按下的数据,不能读到随后移动和抬起复用的事件。 + await page.mouse.move(200, 200); + await page.mouse.down(); + await page.mouse.move(350, 200); + await page.mouse.up(); + await page.evaluate(() => window.__injectedStage.delayedReady); + await page.evaluate(() => { + const state = window.__injectedStage; + state.sameDimension = state.dimensions[0] === 'enter' && !state.dimensions.includes('leave'); + state.stage.eventSystem.cancelPointer(1); + state.stage.eventSystem.cancelPointer(1); + state.cancelledOnce = state.dimensions.filter(action => action === 'leave').length === 1; + state.allowed = { ...state.counts }; + }); + await page.mouse.move(point.x + 2, point.y + 2); + await page.evaluate(() => { + const state = window.__injectedStage; + state.reentered = state.dimensions[state.dimensions.length - 1] === 'enter'; + const beforeOff = state.dimensions.length; + state.chart.off('dimensionHover', state.onDimensionHover); + state.stage.eventSystem.cancelPointer(1); + state.unsubscribed = state.dimensions.length === beforeOff; + state.stage.eventSystem.input.canvas.off('pointercancel', state.onRawCancel); + // Cleanup must use the source actually subscribed, even if options have since been replaced. + const unexpected = { + on() {}, + off() { + throw new Error('unsubscribed from the wrong source'); + } + }; + state.chart.getCompiler().getOption().eventSource = { canvas: unexpected, window: unexpected }; + state.chart.release(); + state.cleaned = + state.stage.releaseStatus !== 'released' && + state.count() === state.initialListeners && + state.stage.defaultLayer.childrenCount === state.initialChildren && + state.stage.hooks.beforeRender.taps.length === state.initialHooks; + state.stage.render(); + }); + // 原图表仍使用 DOM 事件源,移出画布后固定在无悬浮状态截图。 + await page.mouse.move(900, 700); + }, + async verify(page) { + await page.evaluate(async () => { + const s = window.__injectedStage; + const delayedCorrect = ['dom', 'injected'].every(key => { + const event = s.delayed[key]; + return event.type === 'pointerdown' && event.x === 200 && event.buttons === 1; + }); + if ( + !delayedCorrect || + !s.sameDimension || + !s.cancelledOnce || + !s.reentered || + !s.unsubscribed || + !s.crosshairVisible || + !s.keepsScheduling || + s.blocked.canvas !== 0 || + s.blocked.window !== 0 || + !s.allowed.canvas || + !s.allowed.window || + s.allowed.cancel !== 1 || + s.allowed.rawCancel !== 1 || + !s.cleaned + ) { + const { assertionError } = await import('/suite/assertions.mjs'); + throw assertionError( + '传入 Stage 的绘制、输入或释放边界异常:' + + JSON.stringify({ + dimensions: s.dimensions, + delayed: s.delayed, + sameDimension: s.sameDimension, + cancelledOnce: s.cancelledOnce, + reentered: s.reentered, + unsubscribed: s.unsubscribed, + crosshairVisible: s.crosshairVisible, + keepsScheduling: s.keepsScheduling, + blocked: s.blocked, + allowed: s.allowed, + cleaned: s.cleaned + }) + ); + } + }); + } +}; diff --git a/packages/vchart/__tests__/visual/cases/api/state/dimension-index-leave.mjs b/packages/vchart/__tests__/visual/cases/api/state/dimension-index-leave.mjs new file mode 100644 index 0000000000..625860d2e9 --- /dev/null +++ b/packages/vchart/__tests__/visual/cases/api/state/dimension-index-leave.mjs @@ -0,0 +1,57 @@ +import { interactionFrame } from '../../../interaction-helpers.mjs'; + +/** + * 验证目的:程序化激活的维度也能在离开画布时清理。 + * 图表类型:line;公开 setDimensionIndex 激活 A,显式配置折线点的 dimension_hover。 + * 场景条件:光标只经过 padding 留白,不以命中数据点的 pointermove 建立活动缓存。 + * 最终检查:调用后一个点高亮;移出画布后没有残留的 dimension_hover 状态。 + * 覆盖边界:不验证 Tooltip 和 crosshair 的程序化显示。 + */ +export default { + createSpec() { + return { + type: 'line', + padding: 80, + animation: false, + data: { + values: [ + { x: 'A', y: 20 }, + { x: 'B', y: 30 }, + { x: 'C', y: 15 } + ] + }, + xField: 'x', + yField: 'y', + point: { state: { dimension_hover: { size: 16, fill: 'red' } } }, + tooltip: { visible: false } + }; + }, + async exercise(page) { + // 留白移动不会命中图表维度,不能替程序化入口补建活动缓存。 + await page.mouse.move(10, 10); + await page.evaluate(() => { + const chart = window.__visualChart; + chart.setDimensionIndex('A', { tooltip: false, crosshair: false }); + window.__dimensionIndexLeave = chart + .getStage() + .findAll(g => g.type === 'symbol' && g.currentStates?.includes('dimension_hover'), true).length; + }); + await page.mouse.move(20, 20); + await page.mouse.move(900, 700); + await interactionFrame(page); + }, + async verify(page) { + // 检查实际图元状态,而不是仅判断 leave 回调是否被调用。 + await page.evaluate(async () => { + const remaining = window.__visualChart + .getStage() + .findAll(g => g.type === 'symbol' && g.currentStates?.includes('dimension_hover'), true).length; + if (window.__dimensionIndexLeave !== 1 || remaining !== 0) { + const { assertionError } = await import('/suite/assertions.mjs'); + throw assertionError( + '程序化维度未正确清理:' + JSON.stringify({ activated: window.__dimensionIndexLeave, remaining }) + ); + } + }); + } +}; diff --git a/packages/vchart/__tests__/visual/cases/index.mjs b/packages/vchart/__tests__/visual/cases/index.mjs index 32a80b34d1..b71a79cbec 100644 --- a/packages/vchart/__tests__/visual/cases/index.mjs +++ b/packages/vchart/__tests__/visual/cases/index.mjs @@ -9,6 +9,14 @@ export const cases = [ purpose: '标题重测后图例过滤不使绘图区坍缩', file: './components/title/title-resize-legend-layout.mjs' }, + { id: 'injected-stage', purpose: '传入 Stage 的绘制准备、事件源与资源所有权', file: './api/injected-stage.mjs' }, + { id: 'event-gesture-delay', purpose: '延迟 pinch 保留完整载荷并更新图表数据', file: './api/event-gesture-delay.mjs' }, + { id: 'event-subscription-ownership', purpose: '跨 source 复用回调时完整解绑并隔离实例', file: './api/event-subscription-ownership.mjs' }, + { + id: 'event-throttle-propagation', + purpose: 'throttle 同步回调保留原事件并拦截后续 Stage 监听器', + file: './api/event-throttle-propagation.mjs' + }, { id: 'linear-axis-update-bounds', purpose: '连续轴更新显式边界后实际域与柱几何同步', file: './components/axis/linear-axis-update-bounds.mjs' }, { id: 'band-axis-update-spec', purpose: '分类轴 updateSpec 应用新的主题与标签样式', file: './components/axis/band-axis-update-spec.mjs' }, { id: 'legend-piecewise-domain', purpose: '多节点连续色域图例的完整范围', file: './components/legend/legend-piecewise-domain.mjs' }, @@ -1178,6 +1186,11 @@ export const cases = [ purpose: 'setDimensionIndex 定位来源指定维度的十字线', file: './api/state/dimension-index-area.mjs' }, + { + id: 'dimension-index-leave', + purpose: 'setDimensionIndex 激活维度后经留白移出画布清理折线点高亮', + file: './api/state/dimension-index-leave.mjs' + }, { id: 'custom-mark-text-click', purpose: '来源 customMark 点击回调修改实际图元', diff --git a/packages/vchart/src/compile/compiler.ts b/packages/vchart/src/compile/compiler.ts index cca524c522..7cfa85d09c 100644 --- a/packages/vchart/src/compile/compiler.ts +++ b/packages/vchart/src/compile/compiler.ts @@ -28,6 +28,7 @@ import { createStageFromApp, getVRenderAppEnvParams, resolveVRenderApp } from '. type EventListener = { type: string; callback: (...args: any[]) => void; + unbind?: () => void; }; const POPTIP_FOR_TEXT_PLUGIN_NAME = 'poptipForText'; @@ -143,6 +144,10 @@ export class Compiler implements ICompiler { this._dedupeStagePlugin(POPTIP_FOR_TEXT_PLUGIN_NAME); } + private handleBeforeRender = () => { + this._compileChart?.onBeforeRender(); + }; + initView() { if (this._released) { return; @@ -220,7 +225,12 @@ export class Compiler implements ICompiler { } this._dedupePoptipPlugin(); - this._stage.enableIncrementalAutoRender(); + if (!externalStage) { + this._stage.enableIncrementalAutoRender(); + } else { + // The caller owns stage scheduling; chart preparation still runs before each draw. + this._stage.hooks.beforeRender.tap('chart-event', this.handleBeforeRender); + } // 之前vgrammar 设置了一些默认配置 (this._stage as any).setTheme({ @@ -605,8 +615,8 @@ export class Compiler implements ICompiler { const animationState = markAnimationStates.every(state => state === AnimationStateEnum.appear) ? AnimationStateEnum.appear : markAnimationStates.every(state => state === AnimationStateEnum.disappear) - ? AnimationStateEnum.disappear - : AnimationStateEnum.none; + ? AnimationStateEnum.disappear + : AnimationStateEnum.none; if (!this._stage.context) { this._stage.context = {}; } @@ -732,9 +742,20 @@ export class Compiler implements ICompiler { }; callback.call(null, params); }.bind(this); - this._windowListeners.set(callback, { type, callback: wrappedCallback }); - const windowObject = this._getGlobalThis(); - windowObject?.addEventListener(type, wrappedCallback); + const emitter = this._option.eventSource?.window; + const domTarget = this._getGlobalThis(); + if (emitter) { + emitter.on(type, wrappedCallback); + } else { + domTarget?.addEventListener(type, wrappedCallback); + } + this._windowListeners.set(callback, { + type, + callback: wrappedCallback, + unbind: emitter + ? () => emitter.off(type, wrappedCallback) + : () => domTarget?.removeEventListener(type, wrappedCallback) + }); } else if (source === Event_Source_Type.canvas) { const wrappedCallback = function wrappedCallback(event: any) { // TODO: vgrammar 暂未提供基于事件直接筛选相应 mark 的能力,这里无法获取到相应的 item @@ -751,9 +772,20 @@ export class Compiler implements ICompiler { }; callback.call(null, params); }.bind(this); - this._canvasListeners.set(callback, { type, callback: wrappedCallback }); - const canvasObject = this.getStage()?.window; - canvasObject?.addEventListener(type, wrappedCallback); + const emitter = this._option.eventSource?.canvas; + const domTarget = this.getStage()?.window; + if (emitter) { + emitter.on(type, wrappedCallback); + } else { + domTarget?.addEventListener(type, wrappedCallback); + } + this._canvasListeners.set(callback, { + type, + callback: wrappedCallback, + unbind: emitter + ? () => emitter.off(type, wrappedCallback) + : () => domTarget?.removeEventListener(type, wrappedCallback) + }); } } @@ -770,14 +802,10 @@ export class Compiler implements ICompiler { wrappedCallback && this._stage?.removeEventListener(type, wrappedCallback); this._viewListeners.delete(callback); } else if (source === Event_Source_Type.window) { - const windowObject = this._getGlobalThis(); - const wrappedCallback = this._windowListeners.get(callback)?.callback; - wrappedCallback && windowObject?.removeEventListener(type, wrappedCallback); + this._windowListeners.get(callback)?.unbind?.(); this._windowListeners.delete(callback); } else if (source === Event_Source_Type.canvas) { - const canvasObject = this.getStage()?.window; - const wrappedCallback = this._canvasListeners.get(callback)?.callback; - canvasObject && wrappedCallback && canvasObject?.removeEventListener(type, wrappedCallback); + this._canvasListeners.get(callback)?.unbind?.(); this._canvasListeners.delete(callback); } } @@ -787,10 +815,17 @@ export class Compiler implements ICompiler { if (stage) { stage.hooks.afterRender.unTap('chart-event', this.handleStageRender); + stage.hooks.beforeRender.unTap('chart-event', this.handleBeforeRender); } // 相应的事件remove在model中完成 this._viewListeners.clear(); + this._windowListeners.forEach(({ type }, callback) => + this.removeEventListener(Event_Source_Type.window, type, callback) + ); + this._canvasListeners.forEach(({ type }, callback) => + this.removeEventListener(Event_Source_Type.canvas, type, callback) + ); this._windowListeners.clear(); this._canvasListeners.clear(); } diff --git a/packages/vchart/src/compile/interface/compiler.ts b/packages/vchart/src/compile/interface/compiler.ts index d2cc3e8998..2162202899 100644 --- a/packages/vchart/src/compile/interface/compiler.ts +++ b/packages/vchart/src/compile/interface/compiler.ts @@ -66,7 +66,20 @@ export interface GestureConfig { }; } +export interface ScopedEventSource { + on(type: string, listener: (...args: any[]) => void): unknown; + off(type: string, listener: (...args: any[]) => void): unknown; +} + export interface IRenderOption { + /** Scoped accepted input; chart events still use the scenegraph. + * canvas out/leave are logical viewport transitions, window includes owned drags outside it. + * Events are pooled; delayed chart handlers retain a snapshot. The caller owns both sources. + */ + eventSource?: { + canvas: ScopedEventSource; + window: ScopedEventSource; + }; /** * 配置渲染环境,默认为 'desktop-browser',当需要在非浏览器环境渲染 VChart 时,需要配置该属性。 * - 'desktop-browser': 默认模式,适用于 PC 及 H5 diff --git a/packages/vchart/src/constant/event.ts b/packages/vchart/src/constant/event.ts index 3ff0436e97..980e356b9b 100644 --- a/packages/vchart/src/constant/event.ts +++ b/packages/vchart/src/constant/event.ts @@ -74,6 +74,7 @@ export enum HOOK_EVENT { export const BASE_EVENTS = [ 'pointerdown', 'pointerup', + 'pointercancel', 'pointerupoutside', 'pointertap', // pointerEvent 下的 click 事件 'pointerover', diff --git a/packages/vchart/src/core/vchart.ts b/packages/vchart/src/core/vchart.ts index eed867b69c..05db94bd61 100644 --- a/packages/vchart/src/core/vchart.ts +++ b/packages/vchart/src/core/vchart.ts @@ -1406,7 +1406,7 @@ export class VChart implements IVChart { if (handler) { const index = this._userEvents.findIndex(e => e.eType === eType && e.handler === handler); if (index >= 0) { - this._userEvents.splice(index, 1); + this._userEvents = this._userEvents.filter(e => e.eType !== eType || e.handler !== handler); this._event?.off(eType, handler); } } else { diff --git a/packages/vchart/src/event/bubble.ts b/packages/vchart/src/event/bubble.ts index ec1a30503e..57cf5599a6 100644 --- a/packages/vchart/src/event/bubble.ts +++ b/packages/vchart/src/event/bubble.ts @@ -1,5 +1,5 @@ import { Event_Bubble_Level } from '../constant/event'; -import type { EventCallback, EventHandler, EventParams, EventBubbleLevel } from './interface'; +import type { EventHandler, EventParams, EventBubbleLevel } from './interface'; export type BubbleNode = { handler: EventHandler; @@ -7,7 +7,7 @@ export type BubbleNode = { }; export class Bubble { - private _map: Map, BubbleNode> = new Map(); + private _map: Map, BubbleNode> = new Map(); private _levelNodes: Map = new Map(); constructor() { @@ -20,19 +20,19 @@ export class Bubble { addHandler(handler: EventHandler, level: EventBubbleLevel): this { const node: BubbleNode = { level, handler }; this._levelNodes.get(level)?.push(node); - this._map.set(handler.callback, node); + this._map.set(handler, node); return this; } removeHandler(handler: EventHandler): this { - const node = this._map.get(handler.callback); + const node = this._map.get(handler); if (!node) { return this; } - this._map.delete(handler.callback); + node.handler.wrappedCallback?.cancel?.(); + this._map.delete(handler); const nodes = this._levelNodes.get(node.level); - // 由于顶层 API 封装不是 handler 形式,因此通过 callback 唯一判断 - const index = nodes?.findIndex(n => n.handler.callback === handler.callback); + const index = nodes?.indexOf(node); index !== undefined && index >= 0 && nodes?.splice(index, 1); return this; } @@ -64,6 +64,7 @@ export class Bubble { } release() { + this._map.forEach(({ handler }) => handler.wrappedCallback?.cancel?.()); this._map.clear(); this._levelNodes.clear(); } diff --git a/packages/vchart/src/event/event-dispatcher.ts b/packages/vchart/src/event/event-dispatcher.ts index d0bd20dd7d..b53b3e8421 100644 --- a/packages/vchart/src/event/event-dispatcher.ts +++ b/packages/vchart/src/event/event-dispatcher.ts @@ -1,5 +1,6 @@ import { Bubble } from './bubble'; import { isValid, debounce, throttle, get, isFunction } from '@visactor/vutils'; +import type { FederatedPointerEvent, FederatedWheelEvent } from '@visactor/vrender-core'; import { BASE_EVENTS, Event_Bubble_Level, @@ -126,11 +127,6 @@ export class EventDispatcher implements IEventDispatcher { bubbles.delete(eType); clean = true; } - - if ((handler?.wrappedCallback as any)?.cancel) { - // 取消debounce/throttle事件,释放闭包内部的上下文对象 - (handler.wrappedCallback as any).cancel(); - } } // 某个事件下所有的监听取消之后删除语法层事件的代理 if (clean && this._isValidEvent(eType)) { @@ -375,16 +371,57 @@ export class EventDispatcher implements IEventDispatcher { return Event_Bubble_Level.vchart; } + private _snapshotInputEvent(event: BaseEventParams['event']): BaseEventParams['event'] { + if (!isFunction(event?.clone) || !('pointerId' in event || 'deltaMode' in event)) { + return event; + } + + // shortcut: VRender 1.1.14 clone drops extension payloads and fails on root events; remove when both are supported. + const input = event as FederatedPointerEvent | FederatedWheelEvent; + const EventConstructor = input.constructor as new (manager: typeof input.manager) => typeof input; + const snapshot = Object.assign(new EventConstructor(input.manager), input); + for (const key of [ + 'layer', + 'page', + 'canvas', + 'viewport', + 'client', + 'movement', + 'offset', + 'global', + 'screen' + ] as const) { + snapshot[key] = { ...input[key] }; + } + snapshot.path = input.path?.slice() ?? []; + snapshot.detailPath = input.detailPath?.slice(); + return snapshot; + } + /** * 将用户 query 配置转换为最终事件筛选参数 */ private _parseQuery(handler: EventHandler): EventHandler { const query = handler.query; // 处理 query 带来的函数封装 - if (query?.throttle) { - handler.wrappedCallback = throttle(handler.callback, query.throttle); - } else if (query?.debounce) { - handler.wrappedCallback = debounce(handler.callback, query.debounce); + if (query?.throttle || query?.debounce) { + const wrap = query.throttle ? throttle : debounce; + const callback = wrap( + (getParams: () => EventParams) => handler.callback(getParams()), + query.throttle || query.debounce + ); + handler.wrappedCallback = Object.assign((params: EventParams) => { + let invoked = false; + const result = callback(() => { + invoked = true; + return params; + }); + // throttle can invoke synchronously; only pending callbacks retain a snapshot. + if (!invoked && params.event) { + params.event = this._snapshotInputEvent(params.event); + } + return result; + }, callback); } let level = this._getQueryLevel(query); let type: string | null = null; diff --git a/packages/vchart/src/event/event.ts b/packages/vchart/src/event/event.ts index 17e4b9f796..045e76be5f 100644 --- a/packages/vchart/src/event/event.ts +++ b/packages/vchart/src/event/event.ts @@ -21,7 +21,7 @@ export class Event implements IEvent { private _composedEventMap: Map, { eventType: EventType; event: IComposedEvent }> = new Map(); - private _eventHandlerMap: Map, EventHandler>> = new Map(); + private _eventHandlerMap: Map>> = new Map(); getComposedEventMap() { return this._composedEventMap; } @@ -85,28 +85,15 @@ export class Event implements IEvent { } } } else { - if (callback) { - const storedHandler = this._getEventHandler(eType, callback as EventCallback); - const handler: EventHandler = (storedHandler as unknown as EventHandler< - EventParamsDefinition[Evt] - >) ?? { - callback, - query: null, - // 卸载事件时无需处理 source 以外的参数 - filter: { - nodeName: null, - type: eType, - level: null, - source: (query as EventQuery).source, - markName: null, - filter: null, - userId: null - } - }; - this._eventDispatcher.unregister(eType, handler); - this._removeEventHandler(eType, callback as EventCallback); - } else { - this._eventDispatcher.unregister(eType); + const handlers = this._eventHandlerMap.get(eType); + const source = typeof query === 'function' ? undefined : query?.source; + handlers?.forEach(handler => { + if ((!callback || handler.callback === callback) && (!source || handler.filter?.source === source)) { + this._eventDispatcher.unregister(eType, handler); + handlers.delete(handler); + } + }); + if (!handlers?.size) { this._eventHandlerMap.delete(eType); } } @@ -152,23 +139,8 @@ export class Event implements IEvent { return; } if (!this._eventHandlerMap.has(eventType)) { - this._eventHandlerMap.set(eventType, new Map()); - } - this._eventHandlerMap.get(eventType).set(handler.callback, handler); - } - - private _getEventHandler(eventType: EventType, callback: EventCallback) { - return this._eventHandlerMap.get(eventType)?.get(callback); - } - - private _removeEventHandler(eventType: EventType, callback: EventCallback) { - const handlerMap = this._eventHandlerMap.get(eventType); - if (!handlerMap) { - return; - } - handlerMap.delete(callback); - if (!handlerMap.size) { - this._eventHandlerMap.delete(eventType); + this._eventHandlerMap.set(eventType, new Set()); } + this._eventHandlerMap.get(eventType).add(handler); } } diff --git a/packages/vchart/src/event/events/dimension/base.ts b/packages/vchart/src/event/events/dimension/base.ts index 0368456a61..fef1b6b61e 100644 --- a/packages/vchart/src/event/events/dimension/base.ts +++ b/packages/vchart/src/event/events/dimension/base.ts @@ -85,10 +85,14 @@ export class DimensionEvent implements IComposedEvent { } }); } + this.onDispatch(dimensionInfo); + return dimensionInfo; + } + + protected onDispatch(dimensionInfo: IDimensionInfo[]) { this._callback.call(null, { action: 'enter', dimensionInfo } as unknown as BaseEventParams); - return dimensionInfo; } } diff --git a/packages/vchart/src/event/events/dimension/dimension-click.ts b/packages/vchart/src/event/events/dimension/dimension-click.ts index d0c612c820..0303e369f6 100644 --- a/packages/vchart/src/event/events/dimension/dimension-click.ts +++ b/packages/vchart/src/event/events/dimension/dimension-click.ts @@ -3,20 +3,23 @@ import type { BaseEventParams, EventHandler, EventParamsDefinition, EventType } import { DimensionEvent } from './base'; export class DimensionClickEvent extends DimensionEvent { + private _eventHandler?: EventHandler; + register(eType: Evt, handler: EventHandler) { this._callback = handler.callback; - this._eventDispatcher.register<'pointertap'>('pointertap', { + this._eventHandler = { query: { ...handler.query, source: Event_Source_Type.chart }, callback: this.onClick - }); + }; + this._eventDispatcher.register('pointertap', this._eventHandler); } unregister() { - this._eventDispatcher.unregister('pointertap', { - query: null, - callback: this.onClick - }); + if (this._eventHandler) { + this._eventDispatcher.unregister('pointertap', this._eventHandler); + this._eventHandler = undefined; + } } private onClick = (params: BaseEventParams) => { diff --git a/packages/vchart/src/event/events/dimension/dimension-hover.ts b/packages/vchart/src/event/events/dimension/dimension-hover.ts index 412c152b36..0da745b130 100644 --- a/packages/vchart/src/event/events/dimension/dimension-hover.ts +++ b/packages/vchart/src/event/events/dimension/dimension-hover.ts @@ -7,46 +7,47 @@ import type { IDimensionInfo } from './interface'; export class DimensionHoverEvent extends DimensionEvent { private _cacheDimensionInfo: IDimensionInfo[] | null = null; + private _eventHandlers: Map< + 'pointermove' | 'pointerout' | 'pointercancel' | 'pointerdown', + EventHandler + > = new Map(); register(eType: Evt, handler: EventHandler) { this._callback = handler.callback; - this._eventDispatcher.register<'pointermove'>('pointermove', { + this._eventHandlers.set('pointermove', { query: { ...handler.query, source: Event_Source_Type.chart }, callback: this.onMouseMove }); - this._eventDispatcher.register<'pointerout'>('pointerout', { + this._eventHandlers.set('pointerout', { + query: { ...handler.query, source: Event_Source_Type.canvas }, + callback: this.onMouseOut + }); + + this._eventHandlers.set('pointercancel', { query: { ...handler.query, source: Event_Source_Type.canvas }, callback: this.onMouseOut }); if (isMobileLikeMode(this._mode)) { // 移动端点按也触发 hover - this._eventDispatcher.register<'pointerdown'>('pointerdown', { + this._eventHandlers.set('pointerdown', { query: { ...handler.query, source: Event_Source_Type.chart }, callback: this.onMouseMove }); } + this._eventHandlers.forEach((eventHandler, type) => this._eventDispatcher.register(type, eventHandler)); } unregister() { - this._eventDispatcher.unregister('pointermove', { - query: null, - callback: this.onMouseMove - }); - this._eventDispatcher.unregister('pointerout', { - query: null, - callback: this.onMouseOut - }); + this._eventHandlers.forEach((eventHandler, type) => this._eventDispatcher.unregister(type, eventHandler)); + this._eventHandlers.clear(); + } - if (isMobileLikeMode(this._mode)) { - // 移动端点按也出发 hover - this._eventDispatcher.unregister('pointerdown', { - query: null, - callback: this.onMouseMove - }); - } + protected onDispatch(dimensionInfo: IDimensionInfo[]) { + this._cacheDimensionInfo = dimensionInfo.length ? dimensionInfo.slice() : null; + super.onDispatch(dimensionInfo); } private onMouseMove = (params: BaseEventParams) => { @@ -57,26 +58,20 @@ export class DimensionHoverEvent extends DimensionEvent { const y = (params.event as any).viewY; const targetDimensionInfo = this.getTargetDimensionInfo(x, y); if (targetDimensionInfo === null && this._cacheDimensionInfo !== null) { - // 鼠标移出某维度 - this._callback.call(null, { - ...params, - action: 'leave', - dimensionInfo: this._cacheDimensionInfo.slice() - }); - this._cacheDimensionInfo = targetDimensionInfo; + this.onMouseOut(params); } else if ( targetDimensionInfo !== null && (this._cacheDimensionInfo === null || targetDimensionInfo.length !== this._cacheDimensionInfo.length || targetDimensionInfo.some((info, i) => !isSameDimensionInfo(info, this._cacheDimensionInfo![i]))) ) { - // 鼠标移入某维度 + // Commit before callbacks: cancellation must not be overwritten on return. + this._cacheDimensionInfo = targetDimensionInfo; this._callback.call(null, { ...params, action: 'enter', dimensionInfo: targetDimensionInfo.slice() }); - this._cacheDimensionInfo = targetDimensionInfo; } else if (targetDimensionInfo !== null) { // 鼠标在某维度上滑动 this._callback.call(null, { @@ -91,12 +86,11 @@ export class DimensionHoverEvent extends DimensionEvent { if (!params || params.chart?.getOption()?.globalInstance?.disableDimensionHoverEvent?.()) { return; } - // 鼠标移出某维度 - this._callback.call(null, { - ...params, - action: 'leave', - dimensionInfo: this._cacheDimensionInfo ? this._cacheDimensionInfo.slice() : [] - }); + const previous = this._cacheDimensionInfo; + if (previous === null) { + return; + } this._cacheDimensionInfo = null; + this._callback.call(null, { ...params, action: 'leave', dimensionInfo: previous.slice() }); }; } diff --git a/packages/vchart/src/event/interface.ts b/packages/vchart/src/event/interface.ts index d01b5f79b3..b67b3b0102 100644 --- a/packages/vchart/src/event/interface.ts +++ b/packages/vchart/src/event/interface.ts @@ -19,6 +19,7 @@ export type EventType = | 'pointermove' | 'pointerenter' | 'pointerleave' + | 'pointercancel' | 'pointerout' | 'mousedown' | 'mouseup' @@ -202,7 +203,7 @@ export type EventHandler = { callback: EventCallback; query: EventQuery | null; // 如果有 debounce/throttle 配置则需要封装原始回调函数 - wrappedCallback?: EventCallback; + wrappedCallback?: EventCallback & { cancel?: () => void }; // 转换后的事件筛选配置 filter?: EventFilter; // handler 是否被禁止触发 @@ -247,6 +248,7 @@ export type EventParamsDefinition = { pointermove: BaseEventParams; pointerenter: BaseEventParams; pointerleave: BaseEventParams; + pointercancel: BaseEventParams; pointerout: BaseEventParams; mousedown: BaseEventParams; mouseup: BaseEventParams;