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;