From 72ce3ac8b86aaa35887252feee7be5df89831411 Mon Sep 17 00:00:00 2001 From: xile611 Date: Tue, 13 Oct 2026 08:32:08 +0000 Subject: [PATCH 1/9] docs: generate changelog of release v1.1.12 --- docs/assets/changelog/en/changelog.md | 11 +++++++++++ docs/assets/changelog/zh/changelog.md | 11 +++++++++++ 2 files changed, 22 insertions(+) diff --git a/docs/assets/changelog/en/changelog.md b/docs/assets/changelog/en/changelog.md index f68f3f6da..dd1126314 100644 --- a/docs/assets/changelog/en/changelog.md +++ b/docs/assets/changelog/en/changelog.md @@ -1,3 +1,14 @@ +# v1.1.12 + +2026-10-13 + + +**🔖 other** + +- **@visactor/vrender-core**: Fix font variant and style measurements for wrapped, clipped and vertical text. + +[more detail about v1.1.12](https://github.com/VisActor/VRender/releases/tag/v1.1.12) + # v1.1.3 2026-07-02 diff --git a/docs/assets/changelog/zh/changelog.md b/docs/assets/changelog/zh/changelog.md index 6eaaba3be..beb1e01f7 100644 --- a/docs/assets/changelog/zh/changelog.md +++ b/docs/assets/changelog/zh/changelog.md @@ -1,3 +1,14 @@ +# v1.1.12 + +2026-10-13 + + +**🔖 其他** + +- **@visactor/vrender-core**: Fix font variant and style measurements for wrapped, clipped and vertical text. + +[更多详情请查看 v1.1.12](https://github.com/VisActor/VRender/releases/tag/v1.1.12) + # v1.1.3 2026-07-02 From c08070314f21accb4cd75c2db7774b46c7aa7062 Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Tue, 27 Oct 2026 21:09:29 +0800 Subject: [PATCH 2/9] feat: support host-driven stage composition and pointer cancellation --- .../render/interactive-graphic-bounds.test.ts | 3 +- packages/vrender-core/src/core/stage.ts | 69 +++++++++++++++---- .../vrender-core/src/event/event-manager.ts | 19 +++++ .../vrender-core/src/event/event-system.ts | 24 ++++++- .../src/event/federated-event/base-event.ts | 2 +- packages/vrender-core/src/interface/event.ts | 1 + packages/vrender-core/src/interface/stage.ts | 11 ++- .../contributions/render/draw-interceptor.ts | 41 ++++++----- 8 files changed, 134 insertions(+), 36 deletions(-) diff --git a/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts b/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts index 6fb9c1b1e..c0be10733 100644 --- a/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts +++ b/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts @@ -31,8 +31,7 @@ function createDrawContextStub() { hoisted, drawContext: { stage: { - tryInitInteractiveLayer: (): void => undefined, - getLayer: (name: string): any => (name === '_builtin_interactive' ? interactiveLayer : undefined) + getInteractiveContainer: (): any => interactiveLayer } } }; diff --git a/packages/vrender-core/src/core/stage.ts b/packages/vrender-core/src/core/stage.ts index 0808dbf6a..89640dc57 100644 --- a/packages/vrender-core/src/core/stage.ts +++ b/packages/vrender-core/src/core/stage.ts @@ -9,6 +9,7 @@ import { } from '@visactor/vutils'; import type { IGraphic, + IGroup, IExportType, IStage, IStageParams, @@ -213,6 +214,7 @@ export class Stage extends Group implements IStage { protected lastRenderparams?: Partial; protected interactiveLayer?: ILayer; + protected interactiveGroup?: Group; protected supportInteractiveLayer: boolean; protected timeline: ITimeline; declare rootSharedStateScope?: SharedStateScope>; @@ -268,7 +270,7 @@ export class Stage extends Group implements IStage { deps.pickerServiceFactory ?? (deps.pickerService ? () => deps.pickerService as IPickerService - : application.pickerServiceFactory ?? (() => new DefaultGlobalPickerService())); + : (application.pickerServiceFactory ?? (() => new DefaultGlobalPickerService()))); this.window = deps.window ?? this.windowFactory(); this.renderService = deps.renderService ?? @@ -368,6 +370,16 @@ export class Stage extends Group implements IStage { this._afterClearScreen = params.afterClearScreen; this._afterClearRect = params.afterClearRect; this.supportInteractiveLayer = params.interactiveLayer !== false; + if (params.interactiveLayer === 'group') { + // 在首帧遍历前建好,避免第一次高亮时增添节点而漏绘。 + this.interactiveGroup = new Group({ zIndex: Number.MAX_SAFE_INTEGER, pickable: false }); + this.interactiveGroup.name = '_builtin_interactive'; + const group = new Group({}); + group.id = '_interactive_group'; + group.attachShadow(); + this.interactiveGroup.add(group); + this.defaultLayer.add(this.interactiveGroup); + } if (!params.optimize) { params.optimize = { tickRenderMode: 'effect' @@ -820,7 +832,7 @@ export class Stage extends Group implements IStage { } // TODO:顺序可能会存在问题 // 支持交互层,且没有创建过,那就创建 - if (this.supportInteractiveLayer && !this.interactiveLayer) { + if (this.supportInteractiveLayer && !this.interactiveGroup && !this.interactiveLayer) { this.interactiveLayer = this.createLayer(); this.interactiveLayer.name = '_builtin_interactive'; this.interactiveLayer.attribute.pickable = false; @@ -831,6 +843,11 @@ export class Stage extends Group implements IStage { // }); } + getInteractiveContainer(): IGroup | undefined { + this.tryInitInteractiveLayer(); + return this.interactiveGroup ?? this.interactiveLayer; + } + clearViewBox(color?: string) { this.window.clearViewBox(color); } @@ -839,6 +856,10 @@ export class Stage extends Group implements IStage { if (this.releaseStatus === 'released') { return; } + if (this.params.requestRender) { + this.params.requestRender(); + return; + } this.startAnimate(); const state = this.state; this.state = 'rendering'; @@ -887,6 +908,15 @@ export class Stage extends Group implements IStage { } renderNextFrame(layers?: ILayer[], force?: boolean): void { + if (this.releaseStatus === 'released') { + return; + } + if (this.params.requestRender) { + if (this.state !== 'rendering') { + this.params.requestRender(); + } + return; + } // render状态中调用的不会触发nextFrame,避免loop // if (this.state === 'rendering' && !force) { // console.log('abc'); @@ -1105,6 +1135,7 @@ export class Stage extends Group implements IStage { }); this.interactiveLayer.release(); } + this.interactiveGroup = undefined; this.window.release(); this._ticker?.remTimeline(this?.timeline); this._ticker?.removeListener('tick', this.afterTickCb); @@ -1146,21 +1177,33 @@ export class Stage extends Group implements IStage { return layer[0] as ILayer; } - renderTo(window: IWindow) { + renderTo(window: IWindow, params?: { viewBox?: IBounds; transMatrix?: IMatrix; clear?: boolean }) { if (this.releaseStatus === 'released') { return; } - this.forEachChildren((layer, i) => { - layer.drawTo(window, { - // ...params, - renderService: this.renderService, - viewBox: window.getViewBox(), - transMatrix: window.getViewBoxTransform(), - background: layer === this.defaultLayer ? this.background : undefined, - clear: i === 0, // 第一个layer需要clear - updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty()) + const state = this.state; + this.state = 'rendering'; + try { + if (this.params.requestRender) { + this.hooks.beforeRender.call(this); + } + this.forEachChildren((layer, i) => { + layer.drawTo(window, { + // ...params, + renderService: this.renderService, + viewBox: params?.viewBox ?? window.getViewBox(), + transMatrix: params?.transMatrix ?? window.getViewBoxTransform(), + background: layer === this.defaultLayer ? this.background : undefined, + clear: i === 0 && params?.clear !== false, + updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty()) + }); }); - }); + if (this.params.requestRender) { + this.hooks.afterRender.call(this); + } + } finally { + this.state = state; + } } /** diff --git a/packages/vrender-core/src/event/event-manager.ts b/packages/vrender-core/src/event/event-manager.ts index 18214de14..92eb76db2 100644 --- a/packages/vrender-core/src/event/event-manager.ts +++ b/packages/vrender-core/src/event/event-manager.ts @@ -108,9 +108,28 @@ export class EventManager { this.addEventMapping('pointerover', this.onPointerOver); this.addEventMapping('pointerup', this.onPointerUp); this.addEventMapping('pointerupoutside', this.onPointerUpOutside); + this.addEventMapping('pointercancel', this.onPointerCancel); this.addEventMapping('wheel', this.onWheel); } + protected onPointerCancel = (from: FederatedEvent, target?: IEventTarget): void => { + if (!(from instanceof FederatedPointerEvent)) { + return; + } + const tracking = this.trackingData(from.pointerId); + const pressPaths = Object.values(tracking.pressTargetsByButton); + const pressed = this.findMountedTarget(pressPaths[0]); + const event = this.createPointerEvent(from, 'pointercancel', pressed ?? target); + this.dispatchEvent(event); + if (event.pointerType === 'touch') { + this.dispatchEvent(event, 'touchcancel'); + } + tracking.pressTargetsByButton = {}; + tracking.clicksByButton = {}; + this.freeEvent(event); + this.onPointerOut(from, target); + }; + addEventMapping(type: string, fn: (e: FederatedEvent, target: IEventTarget) => void): void { if (!this.mappingTable[type]) { this.mappingTable[type] = []; diff --git a/packages/vrender-core/src/event/event-system.ts b/packages/vrender-core/src/event/event-system.ts index b71e88aca..d1586c0a3 100644 --- a/packages/vrender-core/src/event/event-system.ts +++ b/packages/vrender-core/src/event/event-system.ts @@ -90,6 +90,7 @@ export class EventSystem { private rootPointerEvent: FederatedPointerEvent; private rootWheelEvent: FederatedWheelEvent; private eventsAdded: boolean; + private readonly nativeEvents: boolean; constructor(params: RenderConfig) { const { @@ -124,6 +125,7 @@ export class EventSystem { pointer: 'pointer' }; + this.nativeEvents = params.nativeEvents !== false; this.resolution = resolution; this.setTargetElement(targetElement); } @@ -233,6 +235,20 @@ export class EventSystem { this.rootPointerEvent.nativeEvent = null; }; + private onPointerCancel = (nativeEvent: NativeEvent): void => { + if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + return; + } + const normalizedEvents = this.normalizeToPointerData(nativeEvent); + for (let i = 0; i < normalizedEvents.length; i++) { + const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); + event.type = 'pointercancel'; + this.manager.mapEvent(event); + } + this.setCursor(this.manager.cursor, this.manager.cursorTarget); + this.rootPointerEvent.nativeEvent = null; + }; + private onPointerOverOut = (nativeEvent: NativeEvent): void => { if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { return; @@ -264,7 +280,7 @@ export class EventSystem { } private addEvents(): void { - if (this.eventsAdded || !this.domElement) { + if (!this.nativeEvents || this.eventsAdded || !this.domElement) { return; } const { globalObj, domElement } = this; @@ -273,9 +289,11 @@ export class EventSystem { if (globalObj.getDocument()) { globalObj.addEventListener('pointermove', this.onPointerMove, true); globalObj.addEventListener('pointerup', this.onPointerUp, true); + globalObj.addEventListener('pointercancel', this.onPointerCancel, true); } else { domElement.addEventListener('pointermove', this.onPointerMove, true); domElement.addEventListener('pointerup', this.onPointerUp, true); + domElement.addEventListener('pointercancel', this.onPointerCancel, true); } domElement.addEventListener('pointerdown', this.onPointerDown, true); domElement.addEventListener('pointerleave', this.onPointerOverOut, true); @@ -296,6 +314,7 @@ export class EventSystem { if (this.supportsTouchEvents) { domElement.addEventListener('touchstart', this.onPointerDown, true); domElement.addEventListener('touchend', this.onPointerUp, true); + domElement.addEventListener('touchcancel', this.onPointerCancel, true); domElement.addEventListener('touchmove', this.onPointerMove, true); } @@ -317,9 +336,11 @@ export class EventSystem { if (globalObj.getDocument()) { globalObj.removeEventListener('pointermove', this.onPointerMove, true); globalObj.removeEventListener('pointerup', this.onPointerUp, true); + globalObj.removeEventListener('pointercancel', this.onPointerCancel, true); } else { domElement.removeEventListener('pointermove', this.onPointerMove, true); domElement.removeEventListener('pointerup', this.onPointerUp, true); + domElement.removeEventListener('pointercancel', this.onPointerCancel, true); } domElement.removeEventListener('pointerdown', this.onPointerDown, true); domElement.removeEventListener('pointerleave', this.onPointerOverOut, true); @@ -340,6 +361,7 @@ export class EventSystem { if (this.supportsTouchEvents) { domElement.removeEventListener('touchstart', this.onPointerDown, true); domElement.removeEventListener('touchend', this.onPointerUp, true); + domElement.removeEventListener('touchcancel', this.onPointerCancel, true); domElement.removeEventListener('touchmove', this.onPointerMove, true); } diff --git a/packages/vrender-core/src/event/federated-event/base-event.ts b/packages/vrender-core/src/event/federated-event/base-event.ts index b0f18f0e7..0d573c093 100644 --- a/packages/vrender-core/src/event/federated-event/base-event.ts +++ b/packages/vrender-core/src/event/federated-event/base-event.ts @@ -206,7 +206,7 @@ export class FederatedEvent implements Event { this.nativeEvent.preventDefault(); } } catch (err) { - this.nativeEvent.preventDefault && + this.nativeEvent?.preventDefault && isFunction(this.nativeEvent.preventDefault) && this.nativeEvent.preventDefault(); } diff --git a/packages/vrender-core/src/interface/event.ts b/packages/vrender-core/src/interface/event.ts index 485c37c57..39430cc6b 100644 --- a/packages/vrender-core/src/interface/event.ts +++ b/packages/vrender-core/src/interface/event.ts @@ -214,6 +214,7 @@ export type IElementLike = Omit void; // 是否支持HTML属性 enableHtmlAttribute: string | boolean | HTMLElement; // 是否支持react-dom(传入ReactDOM) @@ -98,6 +102,8 @@ export interface IStageParams { } export type EventConfig = { + /** 保留事件管理器,由外部输入事件,不监听共享 Canvas/Window。 */ + nativeEvents?: boolean; /** 是否自动阻止事件 */ autoPreventDefault?: boolean; /** @@ -204,6 +210,7 @@ export interface IStage extends INode { */ renderNextFrame: (layers?: ILayer[], force?: boolean) => void; tryInitInteractiveLayer: () => void; + getInteractiveContainer: () => IGroup | undefined; // 画布操作 resize: (w: number, h: number, rerender?: boolean) => void; @@ -224,7 +231,7 @@ export interface IStage extends INode { dirty: (b: IBounds, matrix?: IMatrix) => void; // 考虑操作回放 - renderTo: (window: IWindow, params: { x: number; y: number; width: number; height: number }) => void; + renderTo: (window: IWindow, params?: { viewBox?: IBounds; transMatrix?: IMatrix; clear?: boolean }) => void; renderToNewWindow: (fullImage?: boolean) => IWindow; diff --git a/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts b/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts index 22e3261ba..78fa96837 100644 --- a/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts +++ b/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts @@ -9,7 +9,6 @@ import type { IGraphic, IGraphicRenderDrawParams, IGroup, - ILayer, IRenderService } from '../../../interface'; import { mat4Allocate, matrixAllocate } from '../../../allocator/matrix-allocate'; @@ -356,8 +355,7 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte { skipUpdateCallback: true } ); // 添加到交互层中 - drawContext.stage.tryInitInteractiveLayer(); - const interactiveLayer = drawContext.stage.getLayer('_builtin_interactive'); + const interactiveLayer = drawContext.stage.getInteractiveContainer(); if (interactiveLayer) { const shadowRoot = this.getShadowRoot(interactiveLayer); shadowRoot.add(interactiveGraphic); @@ -365,8 +363,7 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte return true; } else if (interactiveGraphic) { // 从交互层中删除 - drawContext.stage.tryInitInteractiveLayer(); - const interactiveLayer = drawContext.stage.getLayer('_builtin_interactive'); + const interactiveLayer = drawContext.stage.getInteractiveContainer(); if (interactiveLayer) { const shadowRoot = this.getShadowRoot(interactiveLayer); shadowRoot.removeChild(interactiveGraphic); @@ -406,7 +403,7 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte _g = _g.parent; } if (!intree) { - const interactiveLayer = drawContext.stage.getLayer('_builtin_interactive'); + const interactiveLayer = drawContext.stage.getInteractiveContainer(); if (interactiveLayer) { const shadowRoot = this.getShadowRoot(interactiveLayer); shadowRoot.removeChild(graphic); @@ -417,22 +414,32 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte this.processing = true; const { context } = drawContext; context.highPerformanceSave(); - // 直接transform - context.setTransformFromMatrix(baseGraphic.parent.globalTransMatrix, true); - // context.fillRect(0, 0, 100, 100); - // 设置context的transform到上一个节点 - baseGraphic.isContainer - ? drawContribution.renderGroup(baseGraphic as IGroup, drawContext, baseGraphic.parent.globalTransMatrix) - : drawContribution.renderItem(baseGraphic, drawContext); - - context.highPerformanceRestore(); - this.processing = false; + // renderTo 的目标变换必须同时作用于提升后的图元;不修改原图元祖先矩阵。 + const parent = baseGraphic.parent.globalTransMatrix; + const matrix = matrixAllocate.allocateByObj(parent); + if (drawContext.transMatrix) { + const outer = drawContext.transMatrix; + matrix.setValue(outer.a, outer.b, outer.c, outer.d, outer.e, outer.f); + matrix.multiply(parent.a, parent.b, parent.c, parent.d, parent.e, parent.f); + } + try { + context.setTransformFromMatrix(matrix, true); + // context.fillRect(0, 0, 100, 100); + // 设置context的transform到上一个节点 + baseGraphic.isContainer + ? drawContribution.renderGroup(baseGraphic as IGroup, drawContext, matrix) + : drawContribution.renderItem(baseGraphic, drawContext); + } finally { + context.highPerformanceRestore(); + matrixAllocate.free(matrix); + this.processing = false; + } return true; } return false; } - getShadowRoot(interactiveLayer: ILayer) { + getShadowRoot(interactiveLayer: IGroup) { // 获取绑定影子节点的group let group = interactiveLayer.getElementById('_interactive_group') as IGroup; if (!group) { From c947886488e6256fd4b4e2faf063ffa19a5702db Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Wed, 28 Oct 2026 16:08:59 +0800 Subject: [PATCH 3/9] feat: accept host-filtered native input for external stages --- .../unit/common/native-events.test.ts | 136 ++++++++++++++++++ .../vrender-core/src/event/event-system.ts | 133 ++++++++++++++++- packages/vrender-core/src/interface/event.ts | 12 ++ 3 files changed, 280 insertions(+), 1 deletion(-) create mode 100644 packages/vrender-core/__tests__/unit/common/native-events.test.ts diff --git a/packages/vrender-core/__tests__/unit/common/native-events.test.ts b/packages/vrender-core/__tests__/unit/common/native-events.test.ts new file mode 100644 index 000000000..126f7b2a5 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/common/native-events.test.ts @@ -0,0 +1,136 @@ +/** @jest-environment jsdom */ +import { EventEmitter } from '@visactor/vutils'; +import { EventSystem } from '../../../src/event/event-system'; +import type { RenderConfig } from '../../../src/interface/event'; + +// Scene boundary only; normalization, mapping, propagation and click tracking are real. +function setup() { + const canvas = document.createElement('canvas'); + document.body.appendChild(canvas); + const root = Object.assign(new EventEmitter(), { + parent: null, + stage: { renderCount: 0 }, + attribute: {}, + getCursor: () => 'pointer', + pick: () => ({ graphic: root }) + }); + const system = new EventSystem({ + targetElement: canvas, + resolution: 1, + rootNode: root, + global: { supportsMouseEvents: true, supportsPointerEvents: false, supportsTouchEvents: false }, + nativeEvents: false + } as unknown as RenderConfig); + const events: string[] = []; + const errors: unknown[] = []; + let allowed = true; + let authorized: Event; + const arbitrate = (event: Event) => { + if (allowed) { + authorized = event; + } + }; + document.addEventListener('mousedown', arbitrate); + document.addEventListener('mousemove', arbitrate); + document.addEventListener('mouseup', arbitrate); + ['pointerdown', 'pointerup', 'pointercancel', 'pointerout', 'click'].forEach((type) => + root.on(type, () => events.push(type)) + ); + system.setNativeEventOptions({ + target: canvas, + root: document, + pointerEvents: false, + filter: (event) => event === authorized, + mapPoint: (event) => ({ x: (event.clientX - 20) / 2, y: (event.clientY - 10) / 2 }), + onCursor: () => undefined, + onError: (error) => errors.push(error) + }); + return { + system, + canvas, + root, + events, + errors, + allow(value: boolean) { + allowed = value; + }, + send(type: string, target: HTMLElement = canvas) { + target.dispatchEvent(new MouseEvent(type, { bubbles: true, clientX: 60, clientY: 50, button: 0 })); + }, + release() { + system.release(); + ['mousedown', 'mousemove', 'mouseup'].forEach((type) => document.removeEventListener(type, arbitrate)); + canvas.remove(); + expect(errors).toEqual([]); + } + }; +} + +describe('native input ownership', () => { + test('host arbitration precedes normalization and rejected down cannot click on allowed up', () => { + const s = setup(); + const point: number[] = []; + s.root.on('pointerup', (event) => point.push(event.canvasX, event.canvasY)); + s.allow(false); + s.send('mousedown'); + s.allow(true); + s.send('mouseup'); + expect(s.events).toEqual(['pointerup']); + expect(point).toEqual([20, 20]); + s.release(); + }); + + test('takeover cancels the press and hover without a later click', () => { + const s = setup(); + s.send('mousemove'); + s.send('mousedown'); + s.allow(false); + s.send('mousemove'); + s.allow(true); + s.send('mouseup'); + expect(s.events).toContain('pointercancel'); + expect(s.events).toContain('pointerout'); + expect(s.events).not.toContain('click'); + s.release(); + }); + + test('explicit reset is synchronous and idempotent', () => { + const s = setup(); + s.send('mousemove'); + s.send('mousedown'); + s.system.resetNativeEvents(); + const afterReset = s.events.slice(); + expect(afterReset).toContain('pointercancel'); + s.system.resetNativeEvents(); + expect(s.events).toEqual(afterReset); + s.send('mouseup'); + expect(s.events).not.toContain('click'); + s.release(); + }); + + test('authorized input over a foreign DOM element still cannot hit the chart', () => { + const s = setup(); + const button = document.createElement('button'); + document.body.appendChild(button); + s.send('mousedown', button); + s.send('mouseup', button); + expect(s.events).toEqual([]); + button.remove(); + s.release(); + }); + + test('blur clears the gesture and unbinding removes native listeners', () => { + const s = setup(); + s.send('mousedown'); + window.dispatchEvent(new Event('blur')); + s.send('mouseup'); + expect(s.events).toContain('pointercancel'); + expect(s.events).not.toContain('click'); + s.system.setNativeEventOptions(); + const before = s.events.slice(); + s.send('mousedown'); + s.send('mouseup'); + expect(s.events).toEqual(before); + s.release(); + }); +}); diff --git a/packages/vrender-core/src/event/event-system.ts b/packages/vrender-core/src/event/event-system.ts index d1586c0a3..252f347f2 100644 --- a/packages/vrender-core/src/event/event-system.ts +++ b/packages/vrender-core/src/event/event-system.ts @@ -4,7 +4,14 @@ import type { IGlobal, IWindow } from '../interface'; import { EventManager } from './event-manager'; import { FederatedPointerEvent, FederatedWheelEvent } from './federated-event'; import type { FederatedMouseEvent } from './federated-event/mouse-event'; -import type { EventPoint, IElementLike, IEventTarget, NativeEvent, RenderConfig } from '../interface/event'; +import type { + EventPoint, + IElementLike, + IEventTarget, + NativeEvent, + RenderConfig, + INativeEventOptions +} from '../interface/event'; import { clock } from './util'; const MOUSE_POINTER_ID = 1; @@ -131,6 +138,7 @@ export class EventSystem { } release(): void { + this.setNativeEventOptions(); this.removeEvents(); this.manager && this.manager.release(); this.domElement = null; @@ -166,6 +174,129 @@ export class EventSystem { } } + private nativeEventBinding?: { reset(): void; release(): void }; + + /** Bind a DOM input source independently from the render canvas. Filtering precedes pointer state updates. */ + setNativeEventOptions(options?: INativeEventOptions): void { + this.nativeEventBinding?.release(); + this.nativeEventBinding = undefined; + if (!options) { + return; + } + const system = this; + const { manager } = system; + const originalTarget = system.domElement; + const originalMap = system.mapToCanvasPoint; + const lastEvents = new Map(); + let released = false; + system.removeEvents(); + system.domElement = options.target; + system.mapToCanvasPoint = event => options.mapPoint(event as PointerEvent); + + const reset = (pointerId?: number) => { + lastEvents.forEach((input, id) => { + if (pointerId !== undefined && pointerId !== id) { + return; + } + lastEvents.delete(id); + // Cancellation, unlike rejection, must reach the old target and logical canvas listeners. + const event = system.bootstrapEvent(system.rootPointerEvent, input); + event.type = 'pointercancel'; + event.nativeEvent = null; + manager.mapEvent(event); + }); + }; + const receiveInput = (nativeEvent: Event) => { + if (released) { + return; + } + const target = nativeEvent.composedPath?.()[0] ?? nativeEvent.target; + if (target !== options.target || !options.filter(nativeEvent as MouseEvent)) { + if (lastEvents.size) { + reset((nativeEvent as PointerEvent).pointerId ?? 1); + } + return; + } + if (nativeEvent.type === 'wheel') { + manager.mapEvent(system.normalizeWheelEvent(nativeEvent as WheelEvent)); + return; + } + const normalized = system.normalizeToPointerData(nativeEvent as NativeEvent); + normalized.forEach(input => { + const event = system.bootstrapEvent(system.rootPointerEvent, input); + lastEvents.delete(event.pointerId); + try { + manager.mapEvent(event); + if ( + !released && + event.type !== 'pointercancel' && + event.type !== 'pointerleave' && + event.type !== 'pointerout' + ) { + // Retain only active input; pooled federated events are reused by the engine. + lastEvents.set(event.pointerId, input); + } + if (!released) { + options.onCursor(manager.cursor || 'default'); + } + } finally { + system.rootPointerEvent.nativeEvent = null; + } + }); + }; + const handleError = (error: unknown) => { + if (options.onError) { + options.onError(error); + } else { + throw error; + } + }; + const receive = (event: Event) => { + try { + receiveInput(event); + } catch (error) { + handleError(error); + } + }; + const types = options.pointerEvents + ? ['pointerdown', 'pointermove', 'pointerup', 'pointercancel'] + : ['mousedown', 'mousemove', 'mouseup', 'pointercancel']; + // Host arbitration runs first on this root/phase; rejected input never reaches the pointer state machine. + types.forEach(type => options.root.addEventListener(type, receive)); + options.target.addEventListener('wheel', receive); + const leave = () => { + try { + reset(); + } catch (error) { + handleError(error); + } + }; + options.target.addEventListener(options.pointerEvents ? 'pointerleave' : 'mouseleave', leave); + const view = options.target.ownerDocument.defaultView; + view?.addEventListener('blur', leave); + + this.nativeEventBinding = { + reset, + release() { + if (released) { + return; + } + released = true; + types.forEach(type => options.root.removeEventListener(type, receive)); + options.target.removeEventListener('wheel', receive); + options.target.removeEventListener(options.pointerEvents ? 'pointerleave' : 'mouseleave', leave); + view?.removeEventListener('blur', leave); + reset(); + system.domElement = originalTarget; + system.mapToCanvasPoint = originalMap; + } + }; + } + + resetNativeEvents(): void { + this.nativeEventBinding?.reset(); + } + private onPointerDown = (nativeEvent: NativeEvent): void => { if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { return; diff --git a/packages/vrender-core/src/interface/event.ts b/packages/vrender-core/src/interface/event.ts index 39430cc6b..864958e94 100644 --- a/packages/vrender-core/src/interface/event.ts +++ b/packages/vrender-core/src/interface/event.ts @@ -304,3 +304,15 @@ export type GraphicEventType = | 'pinchstart' | 'pinchend' | 'swipe'; + +export interface INativeEventOptions { + target: HTMLElement; + /** Use the host's dispatch root/phase when it arbitrates input before VRender. */ + root: EventTarget; + pointerEvents: boolean; + filter(event: MouseEvent): boolean; + mapPoint(event: MouseEvent): { x: number; y: number }; + onCursor(cursor: string): void; + /** Host error boundary; otherwise listener errors propagate normally. */ + onError?(error: unknown): void; +} From ca8b9c1cb1552f907bab23c362c84ab409fde5b6 Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Wed, 28 Oct 2026 17:40:33 +0800 Subject: [PATCH 4/9] fix: preserve stage option and renderTo call compatibility --- .../en/asd/Basic_Tutorial/Create_Instance.md | 2 + .../zh/asd/Basic_Tutorial/Create_Instance.md | 2 + .../vrender-core/__tests__/types/stage-api.ts | 22 +++++++++++ .../smoke/stage-interactive-group.test.ts | 39 +++++++++++++++++++ packages/vrender-core/src/core/stage.ts | 7 ++-- packages/vrender-core/src/interface/stage.ts | 25 ++++++++++-- 6 files changed, 90 insertions(+), 7 deletions(-) create mode 100644 packages/vrender-core/__tests__/types/stage-api.ts create mode 100644 packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts diff --git a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md index d3b084eda..7713e9723 100644 --- a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md @@ -162,6 +162,8 @@ interface IStageParams { disableDirtyBounds: boolean; // Whether to support interactiveLayer, default is true interactiveLayer: boolean; + // Draw highlights in a Group within the main layer. Defaults to false; when true, takes precedence over interactiveLayer. + interactiveGroup?: boolean; // Whether to support HTML attributes enableHtmlAttribute: string | boolean | HTMLElement; // Whether to support react-dom (pass in ReactDOM) diff --git a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md index 28e4e66a5..d790945d2 100644 --- a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md @@ -162,6 +162,8 @@ interface IStageParams { disableDirtyBounds: boolean; // 是否支持interactiveLayer,默认为true interactiveLayer: boolean; + // 在主层内用 Group 绘制高亮,默认 false;开启后优先于 interactiveLayer,不创建额外交互 Layer。 + interactiveGroup?: boolean; // 是否支持HTML属性 enableHtmlAttribute: string | boolean | HTMLElement; // 是否支持react-dom(传入ReactDOM) diff --git a/packages/vrender-core/__tests__/types/stage-api.ts b/packages/vrender-core/__tests__/types/stage-api.ts new file mode 100644 index 000000000..be220f8c1 --- /dev/null +++ b/packages/vrender-core/__tests__/types/stage-api.ts @@ -0,0 +1,22 @@ +import type { IStage, IStageParams, IWindow } from '../../src/interface'; +import type { Stage } from '../../src/core/stage'; + +// Compile-only regression: preserve boolean consumers, legacy object literals/variables/callbacks, +// and both the public interface and concrete Stage entrypoints. +export function stageApiCompatibility(stage: IStage, concrete: Stage, target: IWindow, options: IStageParams) { + const enabled: boolean = options.interactiveLayer; + const legacy = { x: 10, y: 20, width: 30, height: 40 }; + stage.renderTo(target, { x: 10, y: 20, width: 30, height: 40 }); + stage.renderTo(target, legacy); + concrete.renderTo(target); + concrete.renderTo(target, legacy); + const callback: (window: IWindow, params: typeof legacy) => void = stage.renderTo; + callback(target, legacy); + stage.renderTo(target); + stage.renderTo(target, { clear: false }); + concrete.renderTo(target, { clear: false }); + const group: Partial = { interactiveLayer: false, interactiveGroup: true }; + // @ts-expect-error interactiveLayer remains boolean; group is a separate option. + const invalid: Partial = { interactiveLayer: 'group' }; + return { enabled, group, invalid }; +} diff --git a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts new file mode 100644 index 000000000..53ffafa73 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts @@ -0,0 +1,39 @@ +/** @jest-environment node */ +import { createNodeSmokeStage } from './node-smoke-stage'; +import { createRect } from '../../../src/graphic/rect'; +import type { IStageParams } from '../../../src/interface'; + +// The node smoke canvas is single-layer. Physical-layer combinations are covered by browser rendering. +describe('interactive group and disabled container options', () => { + test.each([ + ['disabled', { interactiveLayer: false }, false, false], + ['group enabled', { interactiveGroup: true }, true, true], + ['both enabled', { interactiveLayer: true, interactiveGroup: true }, true, true], + ['group without a layer', { interactiveLayer: false, interactiveGroup: true }, true, true], + ['both disabled', { interactiveLayer: false, interactiveGroup: false }, false, false] + ] as [string, Partial, boolean, boolean][])('%s', (_, options, useGroup, enabled) => { + const stage = createNodeSmokeStage({ + width: 100, + height: 100, + autoRender: false, + autoRefresh: false, + event: false, + ...options + }); + try { + const container = stage.getInteractiveContainer(); + expect(Boolean(container)).toBe(enabled); + expect(stage.childrenCount).toBe(enabled && !useGroup ? 2 : 1); + if (container) { + expect(container.parent).toBe(useGroup ? stage.defaultLayer : stage); + const rect = createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 }); + stage.defaultLayer.add(rect); + stage.render(); + expect(rect.interactiveGraphic?.baseGraphic).toBe(rect); + expect(rect.interactiveGraphic?.parent).toBe(container.getElementById('_interactive_group')?.shadowRoot); + } + } finally { + stage.release(); + } + }); +}); diff --git a/packages/vrender-core/src/core/stage.ts b/packages/vrender-core/src/core/stage.ts index 89640dc57..66240b865 100644 --- a/packages/vrender-core/src/core/stage.ts +++ b/packages/vrender-core/src/core/stage.ts @@ -34,7 +34,8 @@ import type { PickResult, IPlugin, IGraphicService, - IRenderServiceDrawParams + IRenderServiceDrawParams, + IRenderToParams } from '../interface'; import { DefaultWindow } from './window'; import type { Layer } from './layer'; @@ -370,7 +371,7 @@ export class Stage extends Group implements IStage { this._afterClearScreen = params.afterClearScreen; this._afterClearRect = params.afterClearRect; this.supportInteractiveLayer = params.interactiveLayer !== false; - if (params.interactiveLayer === 'group') { + if (params.interactiveGroup === true) { // 在首帧遍历前建好,避免第一次高亮时增添节点而漏绘。 this.interactiveGroup = new Group({ zIndex: Number.MAX_SAFE_INTEGER, pickable: false }); this.interactiveGroup.name = '_builtin_interactive'; @@ -1177,7 +1178,7 @@ export class Stage extends Group implements IStage { return layer[0] as ILayer; } - renderTo(window: IWindow, params?: { viewBox?: IBounds; transMatrix?: IMatrix; clear?: boolean }) { + renderTo(window: IWindow, params?: IRenderToParams) { if (this.releaseStatus === 'released') { return; } diff --git a/packages/vrender-core/src/interface/stage.ts b/packages/vrender-core/src/interface/stage.ts index 442bf0ab4..0a96029cb 100644 --- a/packages/vrender-core/src/interface/stage.ts +++ b/packages/vrender-core/src/interface/stage.ts @@ -22,6 +22,22 @@ export type IExportType = 'canvas' | 'imageData'; export type IStageCreateContext = { appName?: 'vchart' | 'vgrammar' | 'vtable' | string; }; +/** Options for drawing a stage into another window. Omitted fields use the target window geometry. */ +export interface IRenderToParams { + /** @deprecated Legacy rectangle fields were never applied by renderTo; retained for source compatibility. */ + x?: number; + /** @deprecated Retained and ignored, as in earlier versions. */ + y?: number; + /** @deprecated Retained and ignored, as in earlier versions. */ + width?: number; + /** @deprecated Retained and ignored, as in earlier versions. */ + height?: number; + viewBox?: IBounds; + transMatrix?: IMatrix; + /** Clear the destination before the first layer. Defaults to true. */ + clear?: boolean; +} + export interface IStageParams { // x: number; // y: number; @@ -52,9 +68,10 @@ export interface IStageParams { enableLayout: boolean; // 是否关闭脏矩形检测 disableDirtyBounds: boolean; - // 是否支持interactiveLayer,默认为true - /** group 在主层内合成高亮,不创建额外 Canvas。 */ - interactiveLayer: boolean | 'group'; + // 是否支持独立交互 Layer,默认为 true。 + interactiveLayer: boolean; + /** 在主层内用 Group 绘制高亮,默认为 false;启用后优先于 interactiveLayer,不创建额外交互 Layer。 */ + interactiveGroup?: boolean; /** Delegate invalidation to an external compositor; paint explicitly with renderTo. */ requestRender?: () => void; // 是否支持HTML属性 @@ -231,7 +248,7 @@ export interface IStage extends INode { dirty: (b: IBounds, matrix?: IMatrix) => void; // 考虑操作回放 - renderTo: (window: IWindow, params?: { viewBox?: IBounds; transMatrix?: IMatrix; clear?: boolean }) => void; + renderTo: (window: IWindow, params?: IRenderToParams) => void; renderToNewWindow: (fullImage?: boolean) => IWindow; From ccae87586e308549abd750bbd0ebdff1f0fd5272 Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Wed, 28 Oct 2026 17:50:56 +0800 Subject: [PATCH 5/9] fix: keep renderTo drawing options in third argument --- .../vrender-core/__tests__/types/stage-api.ts | 10 +++++++++- packages/vrender-core/src/core/stage.ts | 15 +++++++++------ packages/vrender-core/src/interface/stage.ts | 17 +++++++---------- 3 files changed, 25 insertions(+), 17 deletions(-) diff --git a/packages/vrender-core/__tests__/types/stage-api.ts b/packages/vrender-core/__tests__/types/stage-api.ts index be220f8c1..92801cd06 100644 --- a/packages/vrender-core/__tests__/types/stage-api.ts +++ b/packages/vrender-core/__tests__/types/stage-api.ts @@ -13,8 +13,16 @@ export function stageApiCompatibility(stage: IStage, concrete: Stage, target: IW const callback: (window: IWindow, params: typeof legacy) => void = stage.renderTo; callback(target, legacy); stage.renderTo(target); + stage.renderTo(target, undefined, { clear: false }); + stage.renderTo(target, legacy, { clear: false }); + concrete.renderTo(target, undefined, { clear: false }); + concrete.renderTo(target, legacy, { clear: false }); + // @ts-expect-error New drawing options must not change the legacy rectangle argument. stage.renderTo(target, { clear: false }); - concrete.renderTo(target, { clear: false }); + // @ts-expect-error Legacy rectangle fields remain required when the second argument is supplied. + stage.renderTo(target, { x: 10 }); + // @ts-expect-error Legacy rectangle fields do not belong to drawing options. + stage.renderTo(target, undefined, { x: 10 }); const group: Partial = { interactiveLayer: false, interactiveGroup: true }; // @ts-expect-error interactiveLayer remains boolean; group is a separate option. const invalid: Partial = { interactiveLayer: 'group' }; diff --git a/packages/vrender-core/src/core/stage.ts b/packages/vrender-core/src/core/stage.ts index 66240b865..5c3db17ba 100644 --- a/packages/vrender-core/src/core/stage.ts +++ b/packages/vrender-core/src/core/stage.ts @@ -35,7 +35,7 @@ import type { IPlugin, IGraphicService, IRenderServiceDrawParams, - IRenderToParams + IRenderToOptions } from '../interface'; import { DefaultWindow } from './window'; import type { Layer } from './layer'; @@ -1178,7 +1178,11 @@ export class Stage extends Group implements IStage { return layer[0] as ILayer; } - renderTo(window: IWindow, params?: IRenderToParams) { + renderTo( + window: IWindow, + _params?: { x: number; y: number; width: number; height: number }, + options?: IRenderToOptions + ) { if (this.releaseStatus === 'released') { return; } @@ -1190,12 +1194,11 @@ export class Stage extends Group implements IStage { } this.forEachChildren((layer, i) => { layer.drawTo(window, { - // ...params, renderService: this.renderService, - viewBox: params?.viewBox ?? window.getViewBox(), - transMatrix: params?.transMatrix ?? window.getViewBoxTransform(), + viewBox: options?.viewBox ?? window.getViewBox(), + transMatrix: options?.transMatrix ?? window.getViewBoxTransform(), background: layer === this.defaultLayer ? this.background : undefined, - clear: i === 0 && params?.clear !== false, + clear: i === 0 && options?.clear !== false, updateBounds: !!(this.dirtyBounds && !this.dirtyBounds.empty()) }); }); diff --git a/packages/vrender-core/src/interface/stage.ts b/packages/vrender-core/src/interface/stage.ts index 0a96029cb..889e09880 100644 --- a/packages/vrender-core/src/interface/stage.ts +++ b/packages/vrender-core/src/interface/stage.ts @@ -23,15 +23,7 @@ export type IStageCreateContext = { appName?: 'vchart' | 'vgrammar' | 'vtable' | string; }; /** Options for drawing a stage into another window. Omitted fields use the target window geometry. */ -export interface IRenderToParams { - /** @deprecated Legacy rectangle fields were never applied by renderTo; retained for source compatibility. */ - x?: number; - /** @deprecated Retained and ignored, as in earlier versions. */ - y?: number; - /** @deprecated Retained and ignored, as in earlier versions. */ - width?: number; - /** @deprecated Retained and ignored, as in earlier versions. */ - height?: number; +export interface IRenderToOptions { viewBox?: IBounds; transMatrix?: IMatrix; /** Clear the destination before the first layer. Defaults to true. */ @@ -248,7 +240,12 @@ export interface IStage extends INode { dirty: (b: IBounds, matrix?: IMatrix) => void; // 考虑操作回放 - renderTo: (window: IWindow, params?: IRenderToParams) => void; + // The legacy rectangle argument is retained unchanged; drawing options belong to the third argument. + renderTo: ( + window: IWindow, + params?: { x: number; y: number; width: number; height: number }, + options?: IRenderToOptions + ) => void; renderToNewWindow: (fullImage?: boolean) => IWindow; From c887361e8fa9bd97ad5aa425868af2864a5609e2 Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Thu, 29 Oct 2026 11:56:02 +0800 Subject: [PATCH 6/9] fix: reuse virtual layer for stage interactions --- .../en/asd/Basic_Tutorial/Create_Instance.md | 4 +- .../zh/asd/Basic_Tutorial/Create_Instance.md | 4 +- .../vrender-core/__tests__/types/stage-api.ts | 6 +-- .../render/interactive-graphic-bounds.test.ts | 3 +- .../smoke/stage-interactive-group.test.ts | 39 ---------------- .../smoke/stage-interactive-layer.test.ts | 46 +++++++++++++++++++ .../contributions/layerHandler/modules.ts | 10 ++-- packages/vrender-core/src/core/stage.ts | 21 ++------- packages/vrender-core/src/interface/stage.ts | 5 +- .../contributions/render/draw-interceptor.ts | 11 +++-- 10 files changed, 72 insertions(+), 77 deletions(-) delete mode 100644 packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts create mode 100644 packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts diff --git a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md index 7713e9723..39a391fec 100644 --- a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md @@ -162,8 +162,8 @@ interface IStageParams { disableDirtyBounds: boolean; // Whether to support interactiveLayer, default is true interactiveLayer: boolean; - // Draw highlights in a Group within the main layer. Defaults to false; when true, takes precedence over interactiveLayer. - interactiveGroup?: boolean; + // Interactive layer mode; omitted uses the environment default. Virtual layers share the main canvas. + interactiveLayerMode?: LayerMode; // Whether to support HTML attributes enableHtmlAttribute: string | boolean | HTMLElement; // Whether to support react-dom (pass in ReactDOM) diff --git a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md index d790945d2..47cd4c762 100644 --- a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md @@ -162,8 +162,8 @@ interface IStageParams { disableDirtyBounds: boolean; // 是否支持interactiveLayer,默认为true interactiveLayer: boolean; - // 在主层内用 Group 绘制高亮,默认 false;开启后优先于 interactiveLayer,不创建额外交互 Layer。 - interactiveGroup?: boolean; + // 交互层模式;缺省沿用环境默认。virtual 复用主层 Canvas。 + interactiveLayerMode?: LayerMode; // 是否支持HTML属性 enableHtmlAttribute: string | boolean | HTMLElement; // 是否支持react-dom(传入ReactDOM) diff --git a/packages/vrender-core/__tests__/types/stage-api.ts b/packages/vrender-core/__tests__/types/stage-api.ts index 92801cd06..587f41db2 100644 --- a/packages/vrender-core/__tests__/types/stage-api.ts +++ b/packages/vrender-core/__tests__/types/stage-api.ts @@ -23,8 +23,8 @@ export function stageApiCompatibility(stage: IStage, concrete: Stage, target: IW stage.renderTo(target, { x: 10 }); // @ts-expect-error Legacy rectangle fields do not belong to drawing options. stage.renderTo(target, undefined, { x: 10 }); - const group: Partial = { interactiveLayer: false, interactiveGroup: true }; - // @ts-expect-error interactiveLayer remains boolean; group is a separate option. + const virtual: Partial = { interactiveLayer: true, interactiveLayerMode: 'virtual' }; + // @ts-expect-error interactiveLayer remains boolean; the layer mode is a separate option. const invalid: Partial = { interactiveLayer: 'group' }; - return { enabled, group, invalid }; + return { enabled, virtual, invalid }; } diff --git a/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts b/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts index c0be10733..04f943540 100644 --- a/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts +++ b/packages/vrender-core/__tests__/unit/render/interactive-graphic-bounds.test.ts @@ -31,7 +31,8 @@ function createDrawContextStub() { hoisted, drawContext: { stage: { - getInteractiveContainer: (): any => interactiveLayer + tryInitInteractiveLayer: (): void => undefined, + getLayer: (): any => interactiveLayer } } }; diff --git a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts deleted file mode 100644 index 53ffafa73..000000000 --- a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-group.test.ts +++ /dev/null @@ -1,39 +0,0 @@ -/** @jest-environment node */ -import { createNodeSmokeStage } from './node-smoke-stage'; -import { createRect } from '../../../src/graphic/rect'; -import type { IStageParams } from '../../../src/interface'; - -// The node smoke canvas is single-layer. Physical-layer combinations are covered by browser rendering. -describe('interactive group and disabled container options', () => { - test.each([ - ['disabled', { interactiveLayer: false }, false, false], - ['group enabled', { interactiveGroup: true }, true, true], - ['both enabled', { interactiveLayer: true, interactiveGroup: true }, true, true], - ['group without a layer', { interactiveLayer: false, interactiveGroup: true }, true, true], - ['both disabled', { interactiveLayer: false, interactiveGroup: false }, false, false] - ] as [string, Partial, boolean, boolean][])('%s', (_, options, useGroup, enabled) => { - const stage = createNodeSmokeStage({ - width: 100, - height: 100, - autoRender: false, - autoRefresh: false, - event: false, - ...options - }); - try { - const container = stage.getInteractiveContainer(); - expect(Boolean(container)).toBe(enabled); - expect(stage.childrenCount).toBe(enabled && !useGroup ? 2 : 1); - if (container) { - expect(container.parent).toBe(useGroup ? stage.defaultLayer : stage); - const rect = createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 }); - stage.defaultLayer.add(rect); - stage.render(); - expect(rect.interactiveGraphic?.baseGraphic).toBe(rect); - expect(rect.interactiveGraphic?.parent).toBe(container.getElementById('_interactive_group')?.shadowRoot); - } - } finally { - stage.release(); - } - }); -}); diff --git a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts new file mode 100644 index 000000000..5600d9d70 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts @@ -0,0 +1,46 @@ +/** @jest-environment node */ +import { createNodeSmokeStage } from './node-smoke-stage'; +import { registerGroupGraphic } from '../../../src/register/register-group'; +import { registerShadowRootGraphic } from '../../../src/register/register-shadowRoot'; +import { createRect } from '../../../src/graphic/rect'; +import type { IStageParams } from '../../../src/interface'; + +describe('interactive layer mode', () => { + beforeAll(() => { + registerGroupGraphic(); + registerShadowRootGraphic(); + }); + test.each([ + ['disabled', { interactiveLayer: false }, false], + ['virtual', { interactiveLayerMode: 'virtual' }, true], + ['explicit enabled', { interactiveLayer: true, interactiveLayerMode: 'virtual' }, true], + ['disabled with mode', { interactiveLayer: false, interactiveLayerMode: 'virtual' }, false] + ] as [string, Partial, boolean][])('%s', (_, options, enabled) => { + const stage = createNodeSmokeStage({ + width: 100, + height: 100, + autoRender: false, + autoRefresh: false, + event: false, + ...options + }); + try { + stage.tryInitInteractiveLayer(); + const layer = stage.getLayer('_builtin_interactive'); + expect(Boolean(layer)).toBe(enabled); + expect(stage.childrenCount).toBe(enabled ? 2 : 1); + if (layer) { + expect(layer.layerMode).toBe('virtual'); + expect(layer.parent).toBe(stage); + expect(layer.getNativeHandler().canvas).toBeNull(); + const rect = createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 }); + stage.defaultLayer.add(rect); + stage.render(); + expect(rect.interactiveGraphic?.baseGraphic).toBe(rect); + expect(rect.interactiveGraphic?.parent).toBe(layer.getElementById('_interactive_group')?.shadowRoot); + } + } finally { + stage.release(); + } + }); +}); diff --git a/packages/vrender-core/src/core/contributions/layerHandler/modules.ts b/packages/vrender-core/src/core/contributions/layerHandler/modules.ts index c39fe2fe6..4ec256ec5 100644 --- a/packages/vrender-core/src/core/contributions/layerHandler/modules.ts +++ b/packages/vrender-core/src/core/contributions/layerHandler/modules.ts @@ -1,19 +1,19 @@ import { // DynamicLayerHandlerContribution, - StaticLayerHandlerContribution - // VirtualLayerHandlerContribution + StaticLayerHandlerContribution, + VirtualLayerHandlerContribution } from '../../constants'; import { CanvasLayerHandlerContribution } from './canvas2d-contribution'; -// import { EmptyLayerHandlerContribution } from './empty-contribution'; +import { EmptyLayerHandlerContribution } from './empty-contribution'; // import { OffscreenLayerHandlerContribution } from './offscreen2d-contribution'; export function bindLayerHandlerModules({ bind }: { bind: any }) { bind(CanvasLayerHandlerContribution).toSelf(); // bind(OffscreenLayerHandlerContribution).toSelf(); - // bind(EmptyLayerHandlerContribution).toSelf(); + bind(EmptyLayerHandlerContribution).toSelf(); bind(StaticLayerHandlerContribution).toService(CanvasLayerHandlerContribution); // bind(DynamicLayerHandlerContribution).toService(OffscreenLayerHandlerContribution); - // bind(VirtualLayerHandlerContribution).toService(EmptyLayerHandlerContribution); + bind(VirtualLayerHandlerContribution).toService(EmptyLayerHandlerContribution); // try { // if (typeof OffscreenCanvas === 'function') { // bind(LayerHandlerContribution).toService(OffscreenLayerHandlerContribution); diff --git a/packages/vrender-core/src/core/stage.ts b/packages/vrender-core/src/core/stage.ts index 5c3db17ba..fb07dd7fc 100644 --- a/packages/vrender-core/src/core/stage.ts +++ b/packages/vrender-core/src/core/stage.ts @@ -215,7 +215,6 @@ export class Stage extends Group implements IStage { protected lastRenderparams?: Partial; protected interactiveLayer?: ILayer; - protected interactiveGroup?: Group; protected supportInteractiveLayer: boolean; protected timeline: ITimeline; declare rootSharedStateScope?: SharedStateScope>; @@ -371,16 +370,6 @@ export class Stage extends Group implements IStage { this._afterClearScreen = params.afterClearScreen; this._afterClearRect = params.afterClearRect; this.supportInteractiveLayer = params.interactiveLayer !== false; - if (params.interactiveGroup === true) { - // 在首帧遍历前建好,避免第一次高亮时增添节点而漏绘。 - this.interactiveGroup = new Group({ zIndex: Number.MAX_SAFE_INTEGER, pickable: false }); - this.interactiveGroup.name = '_builtin_interactive'; - const group = new Group({}); - group.id = '_interactive_group'; - group.attachShadow(); - this.interactiveGroup.add(group); - this.defaultLayer.add(this.interactiveGroup); - } if (!params.optimize) { params.optimize = { tickRenderMode: 'effect' @@ -833,8 +822,8 @@ export class Stage extends Group implements IStage { } // TODO:顺序可能会存在问题 // 支持交互层,且没有创建过,那就创建 - if (this.supportInteractiveLayer && !this.interactiveGroup && !this.interactiveLayer) { - this.interactiveLayer = this.createLayer(); + if (this.supportInteractiveLayer && !this.interactiveLayer) { + this.interactiveLayer = this.createLayer(undefined, this.params.interactiveLayerMode); this.interactiveLayer.name = '_builtin_interactive'; this.interactiveLayer.attribute.pickable = false; this.nextFrameRenderLayerSet.add(this.interactiveLayer as any); // to be fixed @@ -844,10 +833,7 @@ export class Stage extends Group implements IStage { // }); } - getInteractiveContainer(): IGroup | undefined { - this.tryInitInteractiveLayer(); - return this.interactiveGroup ?? this.interactiveLayer; - } + clearViewBox(color?: string) { this.window.clearViewBox(color); @@ -1136,7 +1122,6 @@ export class Stage extends Group implements IStage { }); this.interactiveLayer.release(); } - this.interactiveGroup = undefined; this.window.release(); this._ticker?.remTimeline(this?.timeline); this._ticker?.removeListener('tick', this.afterTickCb); diff --git a/packages/vrender-core/src/interface/stage.ts b/packages/vrender-core/src/interface/stage.ts index 889e09880..1dcc816e8 100644 --- a/packages/vrender-core/src/interface/stage.ts +++ b/packages/vrender-core/src/interface/stage.ts @@ -62,8 +62,8 @@ export interface IStageParams { disableDirtyBounds: boolean; // 是否支持独立交互 Layer,默认为 true。 interactiveLayer: boolean; - /** 在主层内用 Group 绘制高亮,默认为 false;启用后优先于 interactiveLayer,不创建额外交互 Layer。 */ - interactiveGroup?: boolean; + /** 交互层的渲染模式;缺省沿用环境默认,virtual 复用主层 Canvas。 */ + interactiveLayerMode?: LayerMode; /** Delegate invalidation to an external compositor; paint explicitly with renderTo. */ requestRender?: () => void; // 是否支持HTML属性 @@ -219,7 +219,6 @@ export interface IStage extends INode { */ renderNextFrame: (layers?: ILayer[], force?: boolean) => void; tryInitInteractiveLayer: () => void; - getInteractiveContainer: () => IGroup | undefined; // 画布操作 resize: (w: number, h: number, rerender?: boolean) => void; diff --git a/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts b/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts index 78fa96837..3ae557ad3 100644 --- a/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts +++ b/packages/vrender-core/src/render/contributions/render/draw-interceptor.ts @@ -9,6 +9,7 @@ import type { IGraphic, IGraphicRenderDrawParams, IGroup, + ILayer, IRenderService } from '../../../interface'; import { mat4Allocate, matrixAllocate } from '../../../allocator/matrix-allocate'; @@ -355,7 +356,8 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte { skipUpdateCallback: true } ); // 添加到交互层中 - const interactiveLayer = drawContext.stage.getInteractiveContainer(); + drawContext.stage.tryInitInteractiveLayer(); + const interactiveLayer = drawContext.stage.getLayer('_builtin_interactive'); if (interactiveLayer) { const shadowRoot = this.getShadowRoot(interactiveLayer); shadowRoot.add(interactiveGraphic); @@ -363,7 +365,8 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte return true; } else if (interactiveGraphic) { // 从交互层中删除 - const interactiveLayer = drawContext.stage.getInteractiveContainer(); + drawContext.stage.tryInitInteractiveLayer(); + const interactiveLayer = drawContext.stage.getLayer('_builtin_interactive'); if (interactiveLayer) { const shadowRoot = this.getShadowRoot(interactiveLayer); shadowRoot.removeChild(interactiveGraphic); @@ -403,7 +406,7 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte _g = _g.parent; } if (!intree) { - const interactiveLayer = drawContext.stage.getInteractiveContainer(); + const interactiveLayer = drawContext.stage.getLayer('_builtin_interactive'); if (interactiveLayer) { const shadowRoot = this.getShadowRoot(interactiveLayer); shadowRoot.removeChild(graphic); @@ -439,7 +442,7 @@ export class InteractiveDrawItemInterceptorContribution implements IDrawItemInte } return false; } - getShadowRoot(interactiveLayer: IGroup) { + getShadowRoot(interactiveLayer: ILayer) { // 获取绑定影子节点的group let group = interactiveLayer.getElementById('_interactive_group') as IGroup; if (!group) { From c21546cd194907d64bd76ea79b97c3af666b549d Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Thu, 29 Oct 2026 13:34:10 +0800 Subject: [PATCH 7/9] fix: unify host input and virtual layer lifecycle --- .../en/asd/Basic_Tutorial/Create_Instance.md | 2 +- .../guide/en/asd/Basic_Tutorial/Event.md | 14 + .../zh/asd/Basic_Tutorial/Create_Instance.md | 2 +- .../guide/zh/asd/Basic_Tutorial/Event.md | 30 ++ .../__tests__/electron/host-input.test.ts | 9 + .../__tests__/util/host-input.js | 361 ++++++++++++++++ .../src/data-zoom/data-zoom.ts | 2 +- .../src/data-zoom/interaction.ts | 169 ++++---- .../vrender-components/src/slider/slider.ts | 110 +++-- .../vrender-core/__tests__/types/stage-api.ts | 4 +- .../__tests__/unit/common/host-input.test.ts | 126 ++++++ .../unit/common/native-events.test.ts | 43 +- packages/vrender-core/src/core/stage.ts | 27 +- .../vrender-core/src/event/event-manager.ts | 390 +++++++++++++++--- .../vrender-core/src/event/event-system.ts | 349 ++++++---------- .../vrender-core/src/event/input-source.ts | 39 ++ packages/vrender-core/src/interface/event.ts | 22 +- packages/vrender-core/src/interface/stage.ts | 8 +- 18 files changed, 1242 insertions(+), 465 deletions(-) create mode 100644 packages/vrender-components/__tests__/electron/host-input.test.ts create mode 100644 packages/vrender-components/__tests__/util/host-input.js create mode 100644 packages/vrender-core/__tests__/unit/common/host-input.test.ts create mode 100644 packages/vrender-core/src/event/input-source.ts diff --git a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md index 39a391fec..63958527b 100644 --- a/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/en/asd/Basic_Tutorial/Create_Instance.md @@ -163,7 +163,7 @@ interface IStageParams { // Whether to support interactiveLayer, default is true interactiveLayer: boolean; // Interactive layer mode; omitted uses the environment default. Virtual layers share the main canvas. - interactiveLayerMode?: LayerMode; + interactiveLayerMode?: 'static' | 'virtual'; // Whether to support HTML attributes enableHtmlAttribute: string | boolean | HTMLElement; // Whether to support react-dom (pass in ReactDOM) diff --git a/docs/assets/guide/en/asd/Basic_Tutorial/Event.md b/docs/assets/guide/en/asd/Basic_Tutorial/Event.md index 50b4f3ece..542db0618 100644 --- a/docs/assets/guide/en/asd/Basic_Tutorial/Event.md +++ b/docs/assets/guide/en/asd/Basic_Tutorial/Event.md @@ -122,3 +122,17 @@ window['stage'] = stage; ``` 【Note】: It is important to note that the event objects thrown by VRender are reusable, so be careful not to save event objects for later use, as the event object will change. This is particularly important to note in asynchronous processes. + +## Host-owned input and Stage composition + +Set `event: { useNativeEvents: false }` when the host owns DOM listeners. Route only accepted inputs through `stage.eventSystem.handleNativeEvent(nativeEvent, { canvasPoint: { x, y }, inViewport })`. The point uses logical canvas units after removing the host composition transform; do not scale it by DPR. EventSystem then applies the Stage window transform. Federated events already carry viewX/viewY, which Stage.eventPointTransform returns directly. Omitting options uses the default DOM mapping and viewport rules. + +Ignoring an input does not cancel a gesture. Call cancelPointer(pointerId), or cancelAllPointers(), when ownership changes. Cancellation clears pointer state before callbacks; reentrant new input is processed synchronously in FIFO order after the terminal transaction. Repeated cancellation is idempotent. + +`eventSystem.input.canvas` and `.window` expose on/off only. Both carry accepted Stage input, not unfiltered browser-window events. Dispatch order is scenegraph, window, canvas. Canvas out/leave describes logical viewport transitions, never sibling-mark transitions. An outside release emits one window pointerup and no canvas pointerup; the scenegraph retains pointerupoutside. Events are pooled: consume synchronously and save scalars for delayed work. + +Supported input types: pointerdown/move/up/cancel and wheel; mousedown/move/up (rightdown/rightup for the right button); touchstart/move/end/cancel; valid presses generate click/dblclick for mouse/pen, tap/dbltap when touch is supported, and pointertap. Canvas boundaries emit pointerover/enter/out/leave and corresponding mouse aliases. Do not forward native DOM click separately. stopPropagation does not control host authorization; cancel/release invalidate remaining normal dispatch. + +DataZoom and Slider subscribe to the accepted window scope and own one active pointer each. Cancellation keeps applied values and ends the gesture. DataZoom flushes the last accepted delayed move on normal up, discards pending moves on cancel, and commits its final value even with realTime=false. The DOM adapter preserves synchronous touch preventDefault; hosts own touch-action and scrolling policy. + +Use interactiveLayerMode:'virtual' to reuse the primary canvas. The interactive layer is prepared before the first draw and remains after business layers. Default layer selection and boolean interactiveLayer are preserved; false disables the layer. renderTo(window, rectangle?, options?) keeps its legacy second argument. Only explicit requestRender scheduling enables beforeRender/afterRender hooks in renderTo; default calls do not invoke new hooks. Its try/finally restores Stage state on failure without swallowing errors. diff --git a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md index 47cd4c762..4b70a58ab 100644 --- a/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md +++ b/docs/assets/guide/zh/asd/Basic_Tutorial/Create_Instance.md @@ -163,7 +163,7 @@ interface IStageParams { // 是否支持interactiveLayer,默认为true interactiveLayer: boolean; // 交互层模式;缺省沿用环境默认。virtual 复用主层 Canvas。 - interactiveLayerMode?: LayerMode; + interactiveLayerMode?: 'static' | 'virtual'; // 是否支持HTML属性 enableHtmlAttribute: string | boolean | HTMLElement; // 是否支持react-dom(传入ReactDOM) diff --git a/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md b/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md index f838815f7..ac4f8110a 100644 --- a/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md +++ b/docs/assets/guide/zh/asd/Basic_Tutorial/Event.md @@ -122,3 +122,33 @@ window['stage'] = stage; ``` 【注意】:需要注意的是,VRender抛出的事件对象是复用的,所以注意不要保存事件对象在后续使用,因为事件对象会变的。这点在异步流程中需要特别注意 + +## 宿主输入与多 Stage 合成 + +默认 DOM 输入与宿主输入共用 EventSystem 的归一化、拾取和分发路径。宿主接入时关闭 Stage 的默认 DOM 监听: + +```ts +const stage = createStage({ + event: { useNativeEvents: false }, + interactiveLayerMode: 'virtual', + requestRender: () => scheduleHostFrame() +}); +// 先由宿主确定归属;canvasPoint 已去掉宿主合成矩阵,单位为逻辑像素,不乘 DPR。 +stage.eventSystem.handleNativeEvent(nativeEvent, { + canvasPoint: { x, y }, + inViewport: true +}); +// 忽略某一次输入不等于取消。切换所有权、宿主 blur 或开始其他手势时显式取消。 +stage.eventSystem.cancelPointer(pointerId); +stage.eventSystem.cancelAllPointers(); +``` + +坐标链为 client → 宿主 canvas 逻辑坐标 → 去掉宿主合成变换 → canvasPoint → Stage window.pointTransform → view。Stage.eventPointTransform 对 Federated 事件直接返回 viewX/viewY,不会重复解释 client 坐标。未传 options 的 handleNativeEvent 沿用 DOM 坐标与视口判断。 + +获准输入的两个订阅范围位于 `stage.eventSystem.input.canvas/window`,只暴露 on/off。window 是该 Stage 获准处理的输入,不是浏览器全窗口广播;canvas 只接收逻辑视口内输入。图元事件仍走 scenegraph,随后分发 window、canvas 输入源。图元间移动不会产生 canvas out/leave;跨逻辑视口才会。视口外的抬起在 window 发布一次 pointerup,在图元路径派生 pointerupoutside,不向 canvas 发布普通 up。 + +支持表:pointerdown/move/up/cancel、wheel;mouse 的 mousedown/move/up(右键 down/up 为 rightdown/rightup);touch 的 touchstart/move/end/cancel;有效按下/抬起产生 click/dblclick(mouse/pen)、tap/dbltap(支持 touch 时)、pointertap;canvas 边界产生 pointerover/enter/out/leave 及 mouse 对应别名。宿主不要再次转发浏览器 click。事件对象池化,只允许同步消费;异步处理保存所需标量,不能保存事件对象。stopPropagation 不改变宿主输入授权,cancel/release 会中止当前失效输入的后续正常分发。 + +取消先清 press/hover/click 状态,再通知消费者;重复取消不重复结束。取消回调里重新送入的输入在当前事务结束后同步按 FIFO 处理。DataZoom/Slider 每个组件只管理一个活动指针;取消保留最后已应用值并结束拖拽。DataZoom 正常 up 应用最后一次已接受的延迟 move,cancel 丢弃尚未应用的 move;realTime=false 仍发送终态。默认 DOM adapter 保持同步触摸 preventDefault;宿主接入自行决定 touch-action 与滚动策略。 + +virtual 交互 Layer 在第一次绘制准备前创建,保持位于业务 Layer 之后,复用主层 Canvas。默认 Layer 模式不变,interactiveLayer:false 优先禁用交互层。renderTo(window, rectangle?, options?) 保留第二参旧矩形契约,新合成选项在第三参。仅显式设置 requestRender 的宿主调度模式会在 renderTo 调用 beforeRender/afterRender;默认 renderTo 不新增 hook 调用。try/finally 只负责绘制异常时恢复 Stage 状态,不吞掉异常。 diff --git a/packages/vrender-components/__tests__/electron/host-input.test.ts b/packages/vrender-components/__tests__/electron/host-input.test.ts new file mode 100644 index 000000000..597e21abf --- /dev/null +++ b/packages/vrender-components/__tests__/electron/host-input.test.ts @@ -0,0 +1,9 @@ +import { runHostInputChecks } from '../util/host-input'; + +describe('host input and native virtual layers', () => { + it('keeps scoped input, cancellation, component drags and first-frame composition consistent', async () => { + const checks = await runHostInputChecks(); + expect(checks.length).toBeGreaterThan(40); + checks.forEach(check => expect(check.pass).toBe(true)); + }); +}); diff --git a/packages/vrender-components/__tests__/util/host-input.js b/packages/vrender-components/__tests__/util/host-input.js new file mode 100644 index 000000000..287b4b471 --- /dev/null +++ b/packages/vrender-components/__tests__/util/host-input.js @@ -0,0 +1,361 @@ +// Real Canvas/DOM regression fixture; shared by Electron and the source-browser verification. +import { createStage, createRect } from '@visactor/vrender'; +import { DataZoom } from '@visactor/vrender-components'; +import { loadBrowserEnv } from '@visactor/vrender-kits'; +import { vglobal } from '@visactor/vrender-core'; +import { Matrix } from '@visactor/vutils'; +import { Slider } from '@visactor/vrender-components'; +let results; +const check = (name, ok, detail) => { + results.push({ name, pass: !!ok, detail }); + if (!ok) throw Error(name + ': ' + JSON.stringify(detail)); +}; +function setup(component, defaults = false, extra = {}, defer = false) { + const canvas = document.createElement('canvas'); + document.body.appendChild(canvas); + const stage = createStage({ + canvas, + width: 400, + height: 180, + dpr: devicePixelRatio, + autoRender: false, + autoRefresh: false, + interactiveLayerMode: 'virtual', + event: { useNativeEvents: defaults }, + ...extra + }); + if (component) stage.defaultLayer.add(component); + if (!defer) stage.render(); + const sys = stage.eventSystem; + function send(type, x, y, id = 1, inside = true) { + const ev = new PointerEvent(type, { + clientX: x, + clientY: y, + pointerId: id, + pointerType: 'mouse', + button: 0, + buttons: type === 'pointerup' ? 0 : 1, + bubbles: true + }); + if (defaults) canvas.dispatchEvent(ev); + else sys.handleNativeEvent(ev, { canvasPoint: { x, y }, inViewport: inside }); + } + return { + stage, + sys, + send, + release() { + stage.release(); + canvas.remove(); + } + }; +} +function center(g) { + const b = g.globalAABBBounds; + return [(b.x1 + b.x2) / 2, (b.y1 + b.y2) / 2]; +} +function node(s, name) { + let found; + s.stage.find(g => { + if (g.name === name) found = g; + return false; + }, true); + return found; +} +export async function runHostInputChecks() { + results = []; + loadBrowserEnv(); + vglobal.setEnv('browser'); + for (const defaults of [false, true]) { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' }), defaults); + let clicks = 0, + cancels = 0; + a.stage.on('click', () => clicks++); + a.stage.on('pointerdown', () => a.sys.cancelPointer(1)); + a.sys.input.window.on('pointercancel', () => cancels++); + a.send('pointerdown', 30, 30); + a.send('pointerup', 30, 30); + check('synchronous-cancel-' + defaults, clicks === 0 && cancels === 1, { clicks, cancels }); + a.release(); + } + for (const scope of ['target', 'capture', 'window', 'canvas']) { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + let down = 0, + click = 0, + alias = 0; + a.stage.on('click', () => click++); + a.sys.input.canvas.on('mousedown', () => alias++); + const rect = a.stage.defaultLayer.children[0]; + rect.on('pointerdown', () => down++); + if (scope === 'capture') a.stage.addEventListener('pointerdown', () => a.sys.cancelPointer(1), { capture: true }); + else if (scope === 'target') rect.on('pointerdown', () => a.sys.cancelPointer(1)); + else a.sys.input[scope].on('pointerdown', () => a.sys.cancelPointer(1)); + a.send('pointerdown', 30, 30); + a.send('pointerup', 30, 30); + check('cancel-' + scope, click === 0 && alias === 0 && (scope !== 'capture' || down === 0), { down, click, alias }); + a.release(); + } + { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + const order = []; + a.stage.on('pointerdown', () => order.push('down')); + a.stage.on('pointercancel', () => { + order.push('cancel'); + a.send('pointerdown', 30, 30); + }); + a.sys.input.window.on('pointercancel', () => order.push('window-cancel')); + a.send('pointerdown', 30, 30); + a.sys.cancelPointer(1); + check('cancel-reentrant-down', order.join(',') === 'down,cancel,window-cancel,down', order); + a.stage.removeAllListeners(); + a.release(); + } + { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + let w = 0, + c = 0, + click = 0; + a.sys.input.window.on('pointerup', () => w++); + a.sys.input.canvas.on('pointerup', () => c++); + a.stage.on('click', () => click++); + a.send('pointerdown', 30, 30); + a.send('pointerup', 450, 30, 1, false); + check('outside-up', w === 1 && c === 0 && click === 0, { w, c, click }); + a.release(); + } + for (const kind of ['zoom', 'slider']) + for (const delay of kind === 'zoom' ? [0, 30] : [0]) + for (const cancel of [false, true]) { + const component = + kind === 'zoom' + ? new DataZoom({ + position: { x: 30, y: 30 }, + size: { width: 300, height: 50 }, + start: 0.2, + end: 0.8, + realTime: true, + delayType: 'debounce', + delayTime: delay + }) + : new Slider({ x: 30, y: 30, min: 0, max: 100, value: 20, railWidth: 300, railHeight: 10 }); + const a = setup(component); + const all = []; + a.stage.find(g => { + if (g.name) all.push(g.name); + return false; + }, true); + const target = kind === 'zoom' ? node(a, 'startHandlerMask') : node(a, 'sliderStartHandler'); + if (!target) throw Error('missing ' + kind + JSON.stringify(all)); + const pos = center(target); + a.send('pointerdown', ...pos); + a.send('pointermove', pos[0] + 30, pos[1]); + if (cancel) a.sys.cancelPointer(1); + else a.send('pointerup', pos[0] + 100, pos[1]); + const value = kind === 'zoom' ? component._state.start : component.currentValue.startValue; + await new Promise(r => setTimeout(r, 60)); + const after = kind === 'zoom' ? component._state.start : component.currentValue.startValue; + a.send('pointermove', pos[0] + 150, pos[1]); + a.send('pointerup', pos[0] + 150, pos[1]); + const late = kind === 'zoom' ? component._state.start : component.currentValue.startValue; + check( + `${kind}-${delay}-${cancel}`, + value === after && + after === late && + (cancel && delay ? Math.abs(value - 0.2) < 0.001 : value > (kind === 'zoom' ? 0.2 : 20)), + { value, after, late } + ); + a.release(); + } + + // Logical canvas scope must not follow scenegraph sibling boundaries. + { + const a = setup(createRect({ x: 10, y: 10, width: 30, height: 30, fill: 'red' })); + a.stage.defaultLayer.add(createRect({ x: 70, y: 10, width: 30, height: 30, fill: 'blue' })); + a.stage.render(); + let leaves = 0, + enters = 0, + clicks = 0, + doubles = 0; + a.sys.input.canvas.on('pointerout', () => leaves++); + a.sys.input.canvas.on('pointerover', () => enters++); + a.sys.input.canvas.on('click', () => clicks++); + a.sys.input.canvas.on('dblclick', () => doubles++); + a.send('pointermove', 20, 20); + a.send('pointermove', 80, 20); + check('sibling-is-not-canvas-leave', leaves === 0 && enters === 1, { leaves, enters }); + a.send('pointermove', 450, 20, 1, false); + check('logical-leave', leaves === 1, { leaves }); + a.send('pointerdown', 200, 100); + a.send('pointerup', 200, 100); + a.send('pointerdown', 200, 100); + a.send('pointerup', 200, 100); + check('blank-canvas-click', clicks === 2 && doubles === 1, { clicks, doubles }); + a.release(); + } + for (const realTime of [true, false]) + for (const action of ['up', 'cancel', 'outside-cancel', 'release', 'delay-change']) { + const c = new DataZoom({ + position: { x: 30, y: 30 }, + size: { width: 300, height: 50 }, + start: 0.2, + end: 0.8, + realTime, + delayType: 'debounce', + delayTime: 30 + }); + const a = setup(c), + pos = center(node(a, 'startHandlerMask')); + a.send('pointerdown', ...pos); + a.send('pointermove', pos[0] + 30, pos[1]); + a.send('pointermove', pos[0] + 150, pos[1], 2); + if (action === 'up') a.send('pointerup', pos[0] + 100, pos[1]); + if (action === 'cancel') a.sys.cancelPointer(1); + if (action === 'outside-cancel') { + a.stage.on('pointerupoutside', () => a.sys.cancelPointer(1)); + a.send('pointerup', 450, 30, 1, false); + } + if (action === 'release') c.release(); + if (action === 'delay-change') c.setAttributes({ delayTime: 60 }); + await new Promise(r => setTimeout(r, 80)); + check( + 'debounce-' + realTime + '-' + action, + action === 'up' ? c._state.start > 0.2 && c._state.start < 0.4 : c._state.start === 0.2, + { value: c._state.start } + ); + a.release(); + } + for (const kind of ['zoom', 'slider']) { + const c = + kind === 'zoom' + ? new DataZoom({ position: { x: 30, y: 30 }, size: { width: 300, height: 50 }, start: 0.2, end: 0.8 }) + : new Slider({ + x: 30, + y: 30, + min: 0, + max: 100, + value: [20, 70], + range: { draggableTrack: true }, + railWidth: 300, + railHeight: 10 + }); + const a = setup(c), + pos = center(node(a, kind === 'zoom' ? 'startHandlerMask' : 'sliderTrack')); + const value = () => (kind === 'zoom' ? c._state.start : c.currentValue.startValue); + const before = value(); + a.send('pointerdown', ...pos); + a.send('pointermove', pos[0] + 30, pos[1], 2); + check(kind + '-foreign-pointer', value() === before); + a.send('pointermove', pos[0] + 30, pos[1]); + const moved = value(); + check(kind + '-drag', moved > before, { moved, before }); + a.sys.cancelPointer(1); + a.send('pointermove', pos[0] + 70, pos[1]); + check(kind + '-cancel-keeps-value', value() === moved); + a.send('pointerdown', ...center(node(a, kind === 'zoom' ? 'startHandlerMask' : 'sliderTrack'))); + a.send('pointermove', pos[0] + 90, pos[1]); + a.send('pointerup', pos[0] + 90, pos[1]); + check(kind + '-restart', value() > moved, { value: value(), moved }); + a.release(); + } + // Both coordinate consumers must read view coordinates after host inverse and Stage transform. + for (const matrix of [new Matrix(1, 0, 0, 1, 40, 20), new Matrix(1.5, 0.2, 0.3, 0.8, 40, 20)]) { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + a.stage.window.setViewBoxTransform(2, 0, 0, 2, 0, 0); + let point; + a.stage.on('pointerdown', e => (point = [e.viewX, e.viewY, ...Object.values(a.stage.eventPointTransform(e))])); + const local = { x: 40, y: 40 }, + client = { + x: matrix.a * local.x + matrix.c * local.y + matrix.e, + y: matrix.b * local.x + matrix.d * local.y + matrix.f + }; + const canvasPoint = { x: 0, y: 0 }; + matrix.transformPoint(client, canvasPoint); + a.sys.handleNativeEvent( + new PointerEvent('pointerdown', { clientX: client.x, clientY: client.y, pointerId: 1, pointerType: 'mouse' }), + { canvasPoint, inViewport: true } + ); + check( + 'mapped-stage-component-point', + point?.every(v => Math.abs(v - 20) < 0.001), + point + ); + a.release(); + } + // First normal frame and composition frame, later source Layer, runtime Layer insertion, hooks. + for (const route of ['render', 'frame', 'renderTo']) { + const a = setup(null, false, { background: 'transparent' }, true), + target = setup(null, false, { background: 'transparent' }); + const later = a.stage.createLayer(undefined, 'virtual'); + const raised = createRect({ x: 20, y: 20, width: 50, height: 50, fill: 'red', globalZIndex: 1 }); + later.add(raised); + const b = a.stage.createLayer(undefined, 'virtual'); + b.add(createRect({ x: 20, y: 20, width: 50, height: 50, fill: 'blue' })); + const paint = () => { + if (route === 'render') a.stage.render(); + else if (route === 'frame') { + a.stage.renderNextFrame(); + a.stage._doRenderInThisFrame(); + } else a.stage.renderTo(target.stage.window, undefined, { clear: false }); + }; + paint(); + const canvas = (route === 'renderTo' ? target : a).stage.window.getNativeHandler().nativeCanvas; + const pixel = () => + Array.from(canvas.getContext('2d').getImageData(40 * devicePixelRatio, 40 * devicePixelRatio, 1, 1).data); + check('virtual-first-' + route, pixel()[0] === 255 && pixel()[2] === 0, pixel()); + const top = a.stage.createLayer(undefined, 'virtual'); + top.add(createRect({ x: 20, y: 20, width: 50, height: 50, fill: 'green' })); + paint(); + check('virtual-dynamic-' + route, pixel()[0] === 255 && pixel()[1] === 0, pixel()); + a.release(); + target.release(); + } + for (const hosted of [false, true]) { + const a = setup(null, false, hosted ? { requestRender: () => {} } : {}), + target = setup(); + let before = 0, + after = 0; + a.stage.hooks.beforeRender.tap('test', () => { + before++; + const layer = a.stage.createLayer(undefined, 'virtual'); + layer.add(createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 })); + }); + a.stage.hooks.afterRender.tap('test', () => after++); + a.stage.renderTo(target.stage.window); + check('renderTo-hooks-' + hosted, before === (hosted ? 1 : 0) && after === (hosted ? 1 : 0), { before, after }); + if (hosted) { + a.stage.hooks.beforeRender.tap('error', () => { + throw Error('test'); + }); + try { + a.stage.renderTo(target.stage.window); + } catch {} + check('renderTo-restores-state', a.stage.state === 'normal', a.stage.state); + } + a.release(); + target.release(); + } + { + const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' })); + const order = []; + let restarting = false; + a.stage.on('pointerdown', () => { + if (restarting) { + order.push('down'); + a.send('pointermove', 30, 30); + } + }); + a.stage.on('pointerup', () => order.push('up')); + a.stage.on('pointermove', () => order.push('move')); + a.stage.on('pointercancel', () => { + restarting = true; + a.send('pointerdown', 30, 30); + a.send('pointerup', 30, 30); + }); + a.send('pointerdown', 30, 30); + a.sys.cancelPointer(1); + check('cancel-drain-fifo', order.join(',') === 'down,up,move', order); + a.stage.removeAllListeners(); + a.release(); + } + return results; +} diff --git a/packages/vrender-components/src/data-zoom/data-zoom.ts b/packages/vrender-components/src/data-zoom/data-zoom.ts index 878852fb6..39595942c 100644 --- a/packages/vrender-components/src/data-zoom/data-zoom.ts +++ b/packages/vrender-components/src/data-zoom/data-zoom.ts @@ -196,8 +196,8 @@ export class DataZoom extends AbstractComponent> { /** * 浏览器上的事件必须解绑,防止内存泄漏,场景树上的事件会自动解绑 */ - super.release(all); this._interaction.clearDragEvents(); + super.release(all); } /** 外部重置组件的起始状态 */ diff --git a/packages/vrender-components/src/data-zoom/interaction.ts b/packages/vrender-components/src/data-zoom/interaction.ts index 98a650be1..d26b68fa4 100644 --- a/packages/vrender-components/src/data-zoom/interaction.ts +++ b/packages/vrender-components/src/data-zoom/interaction.ts @@ -1,8 +1,6 @@ import { DataZoomActiveTag, IDataZoomInteractiveEvent, type DataZoomAttributes } from './type'; -import { getEndTriggersOfDrag } from '../util/event'; import type { IPointLike, Dict, Matrix } from '@visactor/vutils'; -import { vglobal } from '@visactor/vrender-core'; -import type { FederatedPointerEvent, IGroup, IRect, ISymbol, IStage } from '@visactor/vrender-core'; +import type { FederatedPointerEvent, InputEventSource, IGroup, IRect, ISymbol, IStage } from '@visactor/vrender-core'; import { clamp, debounce, EventEmitter, throttle } from '@visactor/vutils'; const delayMap = { debounce: debounce, @@ -65,19 +63,32 @@ export class DataZoomInteraction extends EventEmitter { }; private _spanCache: number; - private _onHandlerPointerMove: (e: FederatedPointerEvent) => void; + private _inputSource?: InputEventSource; + private _activePointerId?: number; + private _finishing = false; + private _pending = false; + private _pendingPoint = { x: 0, y: 0 }; + private _scheduleMove: (() => void) & { cancel?: () => void }; + private _delayTime = 0; + private _delayType = 'debounce'; constructor(props: InteractionAttributes) { super(); - this._initAttrs(props); + this._scheduleMove = this._applyPendingPoint; + this.setAttributes(props); } setAttributes(props: InteractionAttributes): void { + const delayTime = props.attribute.delayTime ?? 0; + const delayType = props.attribute.delayType ?? 'debounce'; + if (delayTime !== this._delayTime || delayType !== this._delayType) { + this.clearDragEvents(); + this._delayTime = delayTime; + this._delayType = delayType; + this._scheduleMove = + delayTime === 0 ? this._applyPendingPoint : delayMap[delayType](this._applyPendingPoint, delayTime); + } this._initAttrs(props); - this._onHandlerPointerMove = - (this.attribute?.delayTime ?? 0) === 0 - ? this._pointerMove - : delayMap[this.attribute?.delayType ?? 'debounce'](this._pointerMove, this.attribute?.delayTime ?? 0); } private _initAttrs(props: InteractionAttributes) { @@ -105,23 +116,14 @@ export class DataZoomInteraction extends EventEmitter { } clearDragEvents() { - const evtTarget = vglobal.env === 'browser' ? vglobal : this.stage; - const triggers = getEndTriggersOfDrag(); - - evtTarget.removeEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - evtTarget.removeEventListener(trigger, this._onHandlerPointerUp); - }); - - (this as unknown as IGroup).off('pointermove', this._onHandlerPointerMove, { - capture: true - }); - } - - clearVGlobalEvents() { - (vglobal.env === 'browser' ? vglobal : this.stage).removeEventListener('touchmove', this._handleTouchMove, { - passive: false - }); + this._scheduleMove?.cancel?.(); + this._pending = false; + this._inputSource?.off('pointermove', this._onHandlerPointerMove); + this._inputSource?.off('pointerup', this._onHandlerPointerUp); + this._inputSource?.off('pointercancel', this._onHandlerPointerCancel); + this._inputSource = undefined; + this._activePointerId = undefined; + this._activeState = false; } bindEvents(): void { @@ -162,29 +164,18 @@ export class DataZoomInteraction extends EventEmitter { 'pointerdown', (e: FederatedPointerEvent) => this._onHandlerPointerDown(e, selectedTag) as unknown as EventListener ); - - (vglobal.env === 'browser' ? vglobal : this.stage).addEventListener('touchmove', this._handleTouchMove, { - passive: false - }); } - private _handleTouchMove = (e: TouchEvent) => { - if (this._activeState) { - /** - * https://developer.mozilla.org/zh-CN/docs/Web/CSS/overscroll-behavior - * 由于浏览器的overscroll-behavior属性,需要在move的时候阻止浏览器默认行为,否则会因为浏览器检测到scroll行为,阻止pointer事件, - * 抛出pointercancel事件,导致拖拽行为中断。 - */ - e.preventDefault(); - } - }; /** * 拖拽开始事件 * @description 开启activeState + 通过tag判断事件在哪个元素上触发 并 更新交互坐标 */ private _onHandlerPointerDown = (e: FederatedPointerEvent, tag: string) => { - // 清除之前的事件,防止没有被清除掉 + if (this._activeState || this._finishing) { + return; + } this.clearDragEvents(); + this._activePointerId = e.pointerId; if (tag === 'start') { this._activeTag = DataZoomActiveTag.startHandler; this._activeItem = this._startHandlerMask; @@ -204,20 +195,10 @@ export class DataZoomInteraction extends EventEmitter { this._activeState = true; this._activeCache.startPos = this._eventPosToStagePos(e); this._activeCache.lastPos = this._eventPosToStagePos(e); - const evtTarget = vglobal.env === 'browser' ? vglobal : this.stage; - const triggers = getEndTriggersOfDrag(); - - /** - * move的时候,需要通过 capture: true,能够在捕获截断被拦截, - */ - evtTarget.addEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - (this as unknown as IGroup).on('pointermove', this._onHandlerPointerMove, { - capture: true - }); - - triggers.forEach((trigger: string) => { - evtTarget.addEventListener(trigger, this._onHandlerPointerUp); - }); + this._inputSource = this.stage.eventSystem.input.window; + this._inputSource.on('pointermove', this._onHandlerPointerMove); + this._inputSource.on('pointerup', this._onHandlerPointerUp); + this._inputSource.on('pointercancel', this._onHandlerPointerCancel); }; /** @@ -228,10 +209,29 @@ export class DataZoomInteraction extends EventEmitter { * 3. 在startHandler上拖拽 (activeTag === 'startHandler'): 改变lastPos、start & end + 边界处理: startHandler和endHandler交换 => render * 4. 在endHandler上拖拽,同上 */ - private _pointerMove = (e: FederatedPointerEvent) => { + private _onHandlerPointerMove = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId || this._finishing) { + return; + } + if (e.pointerType === 'touch') { + e.preventDefault(); + } + this._eventPosToStagePos(e, this._pendingPoint); + this._pending = true; + this._scheduleMove(); + }; + + private _applyPendingPoint = () => { + if (!this._pending || !this._activeState) { + return; + } + this._pending = false; + this._pointerMove(this._pendingPoint); + }; + + private _pointerMove = (pos: IPointLike) => { const { brushSelect } = this.attribute as DataZoomAttributes; const { position } = this._getLayoutAttrFromConfig(); - const pos = this._eventPosToStagePos(e); const { attPos, size, attSize } = this._layoutCache; const dis = (pos[attPos] - this._activeCache.lastPos[attPos]) / size; @@ -251,7 +251,8 @@ export class DataZoomInteraction extends EventEmitter { shouldRender = false; this._dispatchEvent(IDataZoomInteractiveEvent.maskUpdate); } - this._activeCache.lastPos = pos; + this._activeCache.lastPos.x = pos.x; + this._activeCache.lastPos.y = pos.y; } // 避免attributes相同时, 重复渲染 @@ -353,36 +354,42 @@ export class DataZoomInteraction extends EventEmitter { * 拖拽结束事件 * @description 关闭activeState + 边界情况处理: 防止拖拽后start和end过近 */ - private _onHandlerPointerUp = (e: FederatedPointerEvent) => { - if (this._activeState) { - // brush的时候, 只改变了state, 没有触发重新渲染, 在抬起鼠标时触发 - if (this._activeTag === DataZoomActiveTag.background) { - this._setStateAttr(this._getState().start, this._getState().end); + private _onHandlerPointerUp = (e: FederatedPointerEvent) => this._finish(e, false); + private _onHandlerPointerCancel = (e: FederatedPointerEvent) => this._finish(e, true); + + private _finish(e: FederatedPointerEvent, cancel: boolean): void { + if (e.pointerId !== this._activePointerId || this._finishing) { + return; + } + this._finishing = true; + try { + this._scheduleMove.cancel?.(); + if (!cancel) { + this._applyPendingPoint(); + } + const tag = this._activeTag; + this.clearDragEvents(); + if (tag === DataZoomActiveTag.background) { this._dispatchEvent(IDataZoomInteractiveEvent.stateUpdate, { - start: this._getState().start, - end: this._getState().end, + ...this._getState(), shouldRender: true, - tag: this._activeTag + tag }); } + // Cancellation retains applied values; delayed samples are discarded. realTime=false still commits. + this._dispatchEvent(IDataZoomInteractiveEvent.dataZoomUpdate, { + ...this._getState(), + shouldRender: true, + tag + }); + } finally { + this.clearDragEvents(); + this._finishing = false; } - this._activeState = false; - // 此次dispatch不能被省略 - // 因为pointermove时, 已经将状态更新至最新, 所以在pointerup时, 必定start = state.start & end = state.end - // 而realTime = false时, 需要依赖这次dispatch来更新图表图元 - this._dispatchEvent(IDataZoomInteractiveEvent.dataZoomUpdate, { - start: this._getState().start, - end: this._getState().end, - shouldRender: true, - tag: this._activeTag - }); - - this.clearDragEvents(); - }; + } /** 事件系统坐标转换为stage坐标 */ - private _eventPosToStagePos(e: FederatedPointerEvent) { - const result = { x: 0, y: 0 }; + private _eventPosToStagePos(e: FederatedPointerEvent, result = { x: 0, y: 0 }) { // 1. 外部坐标 -> 内部坐标 const stagePoints = this.stage?.eventPointTransform(e as any) ?? { x: 0, y: 0 }; // updateSpec过程中交互的话, stage可能为空 // 2. 内部坐标 -> 组件坐标 (比如: 给layer设置 scale / x / y) diff --git a/packages/vrender-components/src/slider/slider.ts b/packages/vrender-components/src/slider/slider.ts index f07a5d889..f5e6c3efc 100644 --- a/packages/vrender-components/src/slider/slider.ts +++ b/packages/vrender-components/src/slider/slider.ts @@ -12,6 +12,7 @@ import type { IText, ITextGraphicAttribute, FederatedPointerEvent, + InputEventSource, Cursor } from '@visactor/vrender-core'; import { @@ -26,7 +27,7 @@ import { debounce, isFunction } from '@visactor/vutils'; -import { vglobal, CustomEvent } from '@visactor/vrender-core'; +import { CustomEvent } from '@visactor/vrender-core'; import { graphicCreator } from '../util/graphic-creator'; import { AbstractComponent } from '../core/base'; import { SLIDER_ELEMENT_NAME } from './constant'; @@ -34,7 +35,6 @@ import { SLIDER_ELEMENT_NAME } from './constant'; import type { SliderAttributes } from './type'; import type { ComponentOptions } from '../interface'; import { loadSliderComponent } from './register'; -import { getEndTriggersOfDrag } from '../util/event'; function convertValueToRange(value: number | [number, number]) { if (isArray(value)) { @@ -660,8 +660,8 @@ export class Slider extends AbstractComponent> { text: textConfig.formatter ? textConfig.formatter(this._tooltipState.value) : !this._isHorizontal && align === 'left' - ? `${this._tooltipState.value.toFixed(textConfig.precision ?? 0)} ≈` - : `≈ ${this._tooltipState.value.toFixed(textConfig.precision ?? 0)}` + ? `${this._tooltipState.value.toFixed(textConfig.precision ?? 0)} ≈` + : `≈ ${this._tooltipState.value.toFixed(textConfig.precision ?? 0)}` }); } } @@ -708,9 +708,6 @@ export class Slider extends AbstractComponent> { /** * move的时候,需要显示的设置passive: false,因为在移动端需要禁用浏览器默认行为 */ - (vglobal.env === 'browser' ? vglobal : this.stage).addEventListener('touchmove', this._handleTouchMove, { - passive: false - }); } } @@ -779,40 +776,47 @@ export class Slider extends AbstractComponent> { this._dispatchTooltipEvent('sliderTooltipHide'); }; + private _inputSource?: InputEventSource; + private _activePointerId?: number; + private _onHandlerPointerdown = (e: FederatedPointerEvent) => { + if (this._activePointerId !== undefined) { + return; + } this._clearAllDragEvents(); + this._activePointerId = e.pointerId; this._isChanging = true; const { x, y } = this.stage.eventPointTransform(e); this._currentHandler = e.target as unknown as IGraphic; this._prePos = this._isHorizontal ? x : y; - const triggers = getEndTriggersOfDrag(); - const obj = vglobal.env === 'browser' ? vglobal : this.stage; - - /** - * move的时候,需要通过 capture: true,能够在捕获截断被拦截 - */ - obj.addEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.addEventListener(trigger, this._onHandlerPointerUp); - }); + this._bindDragEvents(this._onHandlerPointerMove); }; - private _clearAllDragEvents() { - const triggers = getEndTriggersOfDrag(); - const obj = vglobal.env === 'browser' ? vglobal : this.stage; - - obj.removeEventListener('pointermove', this._onHandlerPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.removeEventListener(trigger, this._onHandlerPointerUp); - }); + private _bindDragEvents(move: (e: FederatedPointerEvent) => void): void { + this._inputSource = this.stage.eventSystem.input.window; + this._inputSource.on('pointermove', move); + this._inputSource.on('pointerup', this._onHandlerPointerUp); + this._inputSource.on('pointercancel', this._onHandlerPointerUp); + } - obj.removeEventListener('pointermove', this._onTrackPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.removeEventListener(trigger, this._onTrackPointerUp); - }); + private _clearAllDragEvents() { + this._inputSource?.off('pointermove', this._onHandlerPointerMove); + this._inputSource?.off('pointermove', this._onTrackPointerMove); + this._inputSource?.off('pointerup', this._onHandlerPointerUp); + this._inputSource?.off('pointercancel', this._onHandlerPointerUp); + this._inputSource = undefined; + this._activePointerId = undefined; + this._isChanging = false; + this._currentHandler = null; } private _onHandlerPointerMove = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId) { + return; + } + if (e.pointerType === 'touch') { + e.preventDefault(); + } this._isChanging = true; const { railWidth, railHeight, min, max } = this.attribute as SliderAttributes; if (max === min) { @@ -852,39 +856,36 @@ export class Slider extends AbstractComponent> { }; private _onHandlerPointerUp = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId) { + return; + } this._isChanging = false; this._currentHandler = null; this._clearAllDragEvents(); }; - private _handleTouchMove = (e: TouchEvent) => { - if (this._isChanging) { - /** - * https://developer.mozilla.org/zh-CN/docs/Web/CSS/overscroll-behavior - * 由于浏览器的overscroll-behavior属性,需要在move的时候阻止浏览器默认行为,否则会因为浏览器检测到scroll行为,阻止pointer事件, - * 抛出pointercancel事件,导致拖拽行为中断。 - */ - e.preventDefault(); - } - }; - private _onTrackPointerdown = (e: FederatedPointerEvent) => { + e.stopPropagation(); + if (this._activePointerId !== undefined) { + return; + } this._clearAllDragEvents(); + this._activePointerId = e.pointerId; this._isChanging = true; const { x, y } = this.stage.eventPointTransform(e); this._prePos = this._isHorizontal ? x : y; - const triggers = getEndTriggersOfDrag(); - const obj = vglobal.env === 'browser' ? vglobal : this.stage; - - obj.addEventListener('pointermove', this._onTrackPointerMove, { capture: true }); - triggers.forEach((trigger: string) => { - obj.addEventListener(trigger, this._onTrackPointerUp); - }); + this._bindDragEvents(this._onTrackPointerMove); }; private _onTrackPointerMove = (e: FederatedPointerEvent) => { + if (e.pointerId !== this._activePointerId) { + return; + } + if (e.pointerType === 'touch') { + e.preventDefault(); + } this._isChanging = true; const { railWidth, railHeight, min, max, inverse } = this.attribute as SliderAttributes; @@ -945,15 +946,11 @@ export class Slider extends AbstractComponent> { this._dispatchChangeEvent(); }; - private _onTrackPointerUp = (e: FederatedPointerEvent) => { - this._isChanging = false; - - this._clearAllDragEvents(); - }; - private _onRailPointerDown = (e: FederatedPointerEvent) => { + if (this._activePointerId !== undefined) { + return; + } this._clearAllDragEvents(); - this._isChanging = true; const { railWidth, railHeight, min, max } = this.attribute as SliderAttributes; if (max === min) { @@ -1160,10 +1157,7 @@ export class Slider extends AbstractComponent> { /** * 浏览器上的事件必须解绑,防止内存泄漏,场景树上的事件会自动解绑 */ - super.release(all); - (vglobal.env === 'browser' ? vglobal : this.stage).removeEventListener('touchmove', this._handleTouchMove, { - passive: false - }); this._clearAllDragEvents(); + super.release(all); } } diff --git a/packages/vrender-core/__tests__/types/stage-api.ts b/packages/vrender-core/__tests__/types/stage-api.ts index 587f41db2..aeead5ec5 100644 --- a/packages/vrender-core/__tests__/types/stage-api.ts +++ b/packages/vrender-core/__tests__/types/stage-api.ts @@ -26,5 +26,7 @@ export function stageApiCompatibility(stage: IStage, concrete: Stage, target: IW const virtual: Partial = { interactiveLayer: true, interactiveLayerMode: 'virtual' }; // @ts-expect-error interactiveLayer remains boolean; the layer mode is a separate option. const invalid: Partial = { interactiveLayer: 'group' }; - return { enabled, virtual, invalid }; + // @ts-expect-error Interactive layers support physical or virtual backends, not incremental dynamic layers. + const dynamic: Partial = { interactiveLayerMode: 'dynamic' }; + return { enabled, virtual, invalid, dynamic }; } diff --git a/packages/vrender-core/__tests__/unit/common/host-input.test.ts b/packages/vrender-core/__tests__/unit/common/host-input.test.ts new file mode 100644 index 000000000..fa09eadc5 --- /dev/null +++ b/packages/vrender-core/__tests__/unit/common/host-input.test.ts @@ -0,0 +1,126 @@ +/** @jest-environment jsdom */ +import { EventEmitter } from '@visactor/vutils'; +import { EventSystem } from '../../../src/event/event-system'; +import type { RenderConfig } from '../../../src/interface/event'; + +function setup() { + const canvas = document.createElement('canvas'); + const root = Object.assign(new EventEmitter(), { + parent: null, + stage: { renderCount: 0 }, + attribute: {}, + getCursor: () => '', + pick: () => ({ graphic: root }) + }); + const system = new EventSystem({ + targetElement: canvas, + resolution: 1, + rootNode: root, + global: { supportsMouseEvents: true, supportsPointerEvents: false, supportsTouchEvents: false }, + useNativeEvents: false + } as unknown as RenderConfig); + const send = (type: string, inside = true) => + system.handleNativeEvent(new MouseEvent(type, { clientX: 60, clientY: 50, button: 0 }), { + canvasPoint: { x: 20, y: 20 }, + inViewport: inside + }); + return { system, root, send }; +} +test('cancel in down listener prevents later click', () => { + const { system, root, send } = setup(); + const click = jest.fn(); + root.on('pointerdown', () => system.cancelPointer(1)); + root.on('click', click); + send('mousedown'); + send('mouseup'); + expect(click).not.toHaveBeenCalled(); + system.release(); +}); +test('outside up is published once to window only', () => { + const { system, send } = setup(); + const win = jest.fn(); + const canvas = jest.fn(); + system.input.window.on('pointerup', win); + system.input.canvas.on('pointerup', canvas); + send('mousedown'); + send('mouseup', false); + expect(win).toHaveBeenCalledTimes(1); + expect(canvas).not.toHaveBeenCalled(); + system.release(); +}); +test('input reentered during cancel starts after old terminal notifications', () => { + const { system, root, send } = setup(); + const order: string[] = []; + root.on('pointerdown', () => order.push('down')); + root.on('pointercancel', () => { + order.push('cancel'); + send('mousedown'); + }); + system.input.window.on('pointercancel', () => order.push('window-cancel')); + send('mousedown'); + system.cancelPointer(1); + expect(order).toEqual(['down', 'cancel', 'window-cancel', 'down']); + root.removeAllListeners(); + system.release(); +}); + +test.each(['target', 'window', 'canvas'])('release in %s down callback stops further dispatch', scope => { + const { system, root, send } = setup(); + const later = jest.fn(); + if (scope === 'target') { + root.on('pointerdown', () => system.release()); + } else { + system.input[scope].on('pointerdown', () => system.release()); + } + system.input.canvas.on('mousedown', later); + expect(() => send('mousedown')).not.toThrow(); + expect(later).not.toHaveBeenCalled(); + expect(() => send('mouseup')).not.toThrow(); +}); +test('window up cancellation suppresses click and canvas up', () => { + const { system, root, send } = setup(); + const click = jest.fn(); + const up = jest.fn(); + root.on('click', click); + system.input.canvas.on('pointerup', up); + system.input.window.on('pointerup', () => system.cancelPointer(1)); + send('mousedown'); + send('mouseup'); + expect(click).not.toHaveBeenCalled(); + expect(up).not.toHaveBeenCalled(); + system.release(); +}); +test('ignoring one move does not implicitly cancel an accepted press', () => { + const { system, root, send } = setup(); + const click = jest.fn(); + root.on('click', click); + send('mousedown'); // The host does not deliver an unrelated move. + send('mousemove'); + send('mouseup'); + expect(click).toHaveBeenCalledTimes(1); + system.release(); +}); + +test('new input enqueued while draining cancellation stays behind already queued input', () => { + const { system, root, send } = setup(); + const order: string[] = []; + let restarting = false; + root.on('pointerdown', () => { + if (restarting) { + order.push('down'); + send('mousemove'); + } + }); + root.on('pointerup', () => order.push('up')); + root.on('pointermove', () => order.push('move')); + root.on('pointercancel', () => { + restarting = true; + send('mousedown'); + send('mouseup'); + }); + send('mousedown'); + system.cancelPointer(1); + expect(order).toEqual(['down', 'up', 'move']); + root.removeAllListeners(); + system.release(); +}); diff --git a/packages/vrender-core/__tests__/unit/common/native-events.test.ts b/packages/vrender-core/__tests__/unit/common/native-events.test.ts index 126f7b2a5..8681edba0 100644 --- a/packages/vrender-core/__tests__/unit/common/native-events.test.ts +++ b/packages/vrender-core/__tests__/unit/common/native-events.test.ts @@ -19,7 +19,7 @@ function setup() { resolution: 1, rootNode: root, global: { supportsMouseEvents: true, supportsPointerEvents: false, supportsTouchEvents: false }, - nativeEvents: false + useNativeEvents: false } as unknown as RenderConfig); const events: string[] = []; const errors: unknown[] = []; @@ -33,20 +33,29 @@ function setup() { document.addEventListener('mousedown', arbitrate); document.addEventListener('mousemove', arbitrate); document.addEventListener('mouseup', arbitrate); - ['pointerdown', 'pointerup', 'pointercancel', 'pointerout', 'click'].forEach((type) => + ['pointerdown', 'pointerup', 'pointercancel', 'pointerout', 'click'].forEach(type => root.on(type, () => events.push(type)) ); - system.setNativeEventOptions({ - target: canvas, - root: document, - pointerEvents: false, - filter: (event) => event === authorized, - mapPoint: (event) => ({ x: (event.clientX - 20) / 2, y: (event.clientY - 10) / 2 }), - onCursor: () => undefined, - onError: (error) => errors.push(error) - }); + const receive = (event: MouseEvent) => { + if (event !== authorized || event.target !== canvas) { + return; + } + system.handleNativeEvent(event, { + canvasPoint: { x: (event.clientX - 20) / 2, y: (event.clientY - 10) / 2 }, + inViewport: true + }); + }; + const blur = () => system.cancelAllPointers(); + const types = ['mousedown', 'mousemove', 'mouseup']; + types.forEach(type => document.addEventListener(type, receive)); + window.addEventListener('blur', blur); + const unbind = () => { + types.forEach(type => document.removeEventListener(type, receive)); + window.removeEventListener('blur', blur); + }; return { system, + unbind, canvas, root, events, @@ -58,8 +67,9 @@ function setup() { target.dispatchEvent(new MouseEvent(type, { bubbles: true, clientX: 60, clientY: 50, button: 0 })); }, release() { + unbind(); system.release(); - ['mousedown', 'mousemove', 'mouseup'].forEach((type) => document.removeEventListener(type, arbitrate)); + ['mousedown', 'mousemove', 'mouseup'].forEach(type => document.removeEventListener(type, arbitrate)); canvas.remove(); expect(errors).toEqual([]); } @@ -70,7 +80,7 @@ describe('native input ownership', () => { test('host arbitration precedes normalization and rejected down cannot click on allowed up', () => { const s = setup(); const point: number[] = []; - s.root.on('pointerup', (event) => point.push(event.canvasX, event.canvasY)); + s.root.on('pointerup', event => point.push(event.canvasX, event.canvasY)); s.allow(false); s.send('mousedown'); s.allow(true); @@ -85,6 +95,7 @@ describe('native input ownership', () => { s.send('mousemove'); s.send('mousedown'); s.allow(false); + s.system.cancelAllPointers(); s.send('mousemove'); s.allow(true); s.send('mouseup'); @@ -98,10 +109,10 @@ describe('native input ownership', () => { const s = setup(); s.send('mousemove'); s.send('mousedown'); - s.system.resetNativeEvents(); + s.system.cancelAllPointers(); const afterReset = s.events.slice(); expect(afterReset).toContain('pointercancel'); - s.system.resetNativeEvents(); + s.system.cancelAllPointers(); expect(s.events).toEqual(afterReset); s.send('mouseup'); expect(s.events).not.toContain('click'); @@ -126,7 +137,7 @@ describe('native input ownership', () => { s.send('mouseup'); expect(s.events).toContain('pointercancel'); expect(s.events).not.toContain('click'); - s.system.setNativeEventOptions(); + s.unbind(); const before = s.events.slice(); s.send('mousedown'); s.send('mouseup'); diff --git a/packages/vrender-core/src/core/stage.ts b/packages/vrender-core/src/core/stage.ts index fb07dd7fc..055920455 100644 --- a/packages/vrender-core/src/core/stage.ts +++ b/packages/vrender-core/src/core/stage.ts @@ -39,7 +39,7 @@ import type { } from '../interface'; import { DefaultWindow } from './window'; import type { Layer } from './layer'; -import { EventSystem } from '../event'; +import { EventSystem, FederatedMouseEvent } from '../event'; import { Group } from '../graphic/group'; import { Theme } from '../graphic/theme'; import { DefaultGlobalPickerService } from '../picker/global-picker-service'; @@ -797,6 +797,9 @@ export class Stage extends Group implements IStage { canvasId }); this.appendChild(layer); + if (this.interactiveLayer && layer !== this.interactiveLayer) { + this.appendChild(this.interactiveLayer); + } return layer; // const layer = new Layer(this, this.global, this.window, { // main: false, @@ -812,6 +815,9 @@ export class Stage extends Group implements IStage { children.forEach(c => { this.appendChild(c); }); + if (this.interactiveLayer) { + this.appendChild(this.interactiveLayer); + } } removeLayer(ILayerId: number): ILayer | false { return this.removeChild(this.findChildByUid(ILayerId) as IGraphic) as ILayer; @@ -820,7 +826,6 @@ export class Stage extends Group implements IStage { if (this.releaseStatus === 'released') { return; } - // TODO:顺序可能会存在问题 // 支持交互层,且没有创建过,那就创建 if (this.supportInteractiveLayer && !this.interactiveLayer) { this.interactiveLayer = this.createLayer(undefined, this.params.interactiveLayerMode); @@ -833,7 +838,13 @@ export class Stage extends Group implements IStage { // }); } - + private prepareRenderLayers(): void { + // The virtual handler needs a main handler before traversal; lazy creation during draw is too late. + if (this.params.interactiveLayerMode === 'virtual') { + this.tryInitInteractiveLayer(); + } + this.layerService.prepareStageLayer(this); + } clearViewBox(color?: string) { this.window.clearViewBox(color); @@ -850,11 +861,11 @@ export class Stage extends Group implements IStage { this.startAnimate(); const state = this.state; this.state = 'rendering'; - this.layerService.prepareStageLayer(this); if (!this._skipRender) { this.lastRenderparams = params; this.hooks.beforeRender.call(this); if (!this._skipRender) { + this.prepareRenderLayers(); this.renderLayerList(this.children as ILayer[]); this.combineLayersToWindow(); this.nextFrameRenderLayerSet.clear(); @@ -942,10 +953,10 @@ export class Stage extends Group implements IStage { this.startAnimate(); const state = this.state; this.state = 'rendering'; - this.layerService.prepareStageLayer(this); if (this.nextFrameRenderLayerSet.size && !this._skipRender) { this.hooks.beforeRender.call(this); if (!this._skipRender) { + this.prepareRenderLayers(); this.renderLayerList(Array.from(this.nextFrameRenderLayerSet.values()), this.lastRenderparams || {}); this.combineLayersToWindow(); this.nextFrameRenderLayerSet.clear(); @@ -1177,6 +1188,7 @@ export class Stage extends Group implements IStage { if (this.params.requestRender) { this.hooks.beforeRender.call(this); } + this.prepareRenderLayers(); this.forEachChildren((layer, i) => { layer.drawTo(window, { renderService: this.renderService, @@ -1258,7 +1270,10 @@ export class Stage extends Group implements IStage { return this._cursor; } - eventPointTransform(e: PointerEvent | WheelEvent | TouchEvent): { x: number; y: number } { + eventPointTransform(e: PointerEvent | WheelEvent | TouchEvent | FederatedMouseEvent): { x: number; y: number } { + if (e instanceof FederatedMouseEvent) { + return { x: e.viewX, y: e.viewY }; + } const point = this.global.mapToCanvasPoint(e, this.window); return this.stage.window.pointTransform(point.x, point.y); diff --git a/packages/vrender-core/src/event/event-manager.ts b/packages/vrender-core/src/event/event-manager.ts index 92eb76db2..db8036628 100644 --- a/packages/vrender-core/src/event/event-manager.ts +++ b/packages/vrender-core/src/event/event-manager.ts @@ -1,3 +1,4 @@ +import { InputSource } from './input-source'; import type { Dict } from '@visactor/vutils'; import { EventEmitter, Logger, get } from '@visactor/vutils'; import { FederatedMouseEvent, FederatedPointerEvent, FederatedWheelEvent } from './federated-event'; @@ -35,6 +36,17 @@ import type { Cursor, IGraphic } from '../interface'; const PROPAGATION_LIMIT = 2048; type TrackingData = { + generation: number; + inside: boolean; + previousInside: boolean; + ending?: IEventTarget[]; + pointerType: string; + button: number; + canvasX: number; + canvasY: number; + viewX: number; + viewY: number; + pressTargetsByButton: { [id: number]: IEventTarget[]; }; @@ -65,6 +77,16 @@ function isMouseLike(pointerType: string) { } const DEFAULT_CLICK_INTERVAL = 200; +const TOUCH_INPUT_TYPES: Record = { + pointerdown: 'touchstart', + pointermove: 'touchmove', + pointerup: 'touchend' +}; +const MOUSE_INPUT_TYPES: Record = { + pointerdown: 'mousedown', + pointermove: 'mousemove', + pointerup: 'mouseup' +}; export class EventManager { rootTarget: IEventTarget; @@ -112,22 +134,176 @@ export class EventManager { this.addEventMapping('wheel', this.onWheel); } - protected onPointerCancel = (from: FederatedEvent, target?: IEventTarget): void => { - if (!(from instanceof FederatedPointerEvent)) { + private readonly canvasInput = new InputSource(); + private readonly windowInput = new InputSource(); + readonly input = { canvas: this.canvasInput.source, window: this.windowInput.source }; + private currentTracking?: TrackingData; + private currentGeneration = 0; + private terminalDepth = 0; + private dispatchingEvent?: FederatedEvent; + + private inputValid = (): boolean => + !!this.rootTarget && + (this.terminalDepth > 0 || !this.currentTracking || this.currentTracking.generation === this.currentGeneration); + + hasPointer(id: number): boolean { + const data = this.mappingState.trackingData[id] as TrackingData; + if (!data) { + return false; + } + if (data.inside || data.ending) { + return true; + } + for (const button in data.pressTargetsByButton) { + if (data.pressTargetsByButton[button]) { + return true; + } + } + return false; + } + + cancelAllPointers(): void { + for (const id in this.mappingState.trackingData) { + this.cancelPointer(Number(id)); + } + } + + cancelPointer(id: number): void { + if (!this.rootTarget || !this.hasPointer(id)) { + return; + } + const data = this.trackingData(id); + let press = data.ending; + for (const button in data.pressTargetsByButton) { + press = data.pressTargetsByButton[button]; + break; + } + const over = data.overTargets; + const inside = data.inside; + // Commit the terminal state before any callback, including capture listeners. + data.generation++; + data.pressTargetsByButton = {}; + data.clicksByButton = {}; + data.ending = undefined; + data.inside = false; + data.overTargets = []; + this.dispatchingEvent?.stopImmediatePropagation(); + const event = this.allocateEvent(FederatedPointerEvent); + event.type = 'pointercancel'; + event.pointerId = id; + event.pointerType = data.pointerType; + event.button = data.button; + event.nativeEvent = null; + event.canvas.x = data.canvasX; + event.canvas.y = data.canvasY; + event.viewport.x = data.viewX; + event.viewport.y = data.viewY; + event.target = this.findMountedTarget(press) ?? this.findMountedTarget(over); + this.terminalDepth++; + try { + this.dispatchEvent(event); + if (event.pointerType === 'touch') { + this.dispatchEvent(event, 'touchcancel'); + } + this.windowInput.emit('pointercancel', event, this.inputValid); + if (event.pointerType === 'touch') { + this.windowInput.emit('touchcancel', event, this.inputValid); + } + if (inside) { + this.canvasInput.emit('pointercancel', event, this.inputValid); + if (event.pointerType === 'touch') { + this.canvasInput.emit('touchcancel', event, this.inputValid); + } + this.emitBoundary(event, false); + } + if (over?.length && this.rootTarget) { + event.target = this.findMountedTarget(over); + event.path = []; + this.dispatchEvent(event, 'pointerout'); + if (isMouseLike(event.pointerType)) { + this.dispatchEvent(event, 'mouseout'); + } + event.eventPhase = event.AT_TARGET; + while (event.target && this.rootTarget) { + event.currentTarget = event.target; + this.notifyTarget(event, 'pointerleave'); + if (isMouseLike(event.pointerType)) { + this.notifyTarget(event, 'mouseleave'); + } + event.target = event.target.parent as IEventTarget; + } + } + } finally { + this.terminalDepth--; + this.freeEvent(event); + this.cursorTarget = null; + this.cursor = ''; + } + } + + private emitBoundary(event: FederatedPointerEvent, inside: boolean): void { + this.canvasInput.emit(inside ? 'pointerover' : 'pointerout', event, this.inputValid); + this.canvasInput.emit(inside ? 'pointerenter' : 'pointerleave', event, this.inputValid); + if (isMouseLike(event.pointerType)) { + this.canvasInput.emit(inside ? 'mouseover' : 'mouseout', event, this.inputValid); + this.canvasInput.emit(inside ? 'mouseenter' : 'mouseleave', event, this.inputValid); + } + } + + private emitInput(event: FederatedMouseEvent, type = event.type): void { + if (!this.inputValid()) { + return; + } + this.windowInput.emit(type, event, this.inputValid); + if (!this.inputValid()) { return; } - const tracking = this.trackingData(from.pointerId); - const pressPaths = Object.values(tracking.pressTargetsByButton); - const pressed = this.findMountedTarget(pressPaths[0]); - const event = this.createPointerEvent(from, 'pointercancel', pressed ?? target); - this.dispatchEvent(event); + const data = event instanceof FederatedPointerEvent ? this.trackingData(event.pointerId) : undefined; + if (data && data.previousInside !== data.inside) { + data.previousInside = data.inside; + this.emitBoundary(event as FederatedPointerEvent, data.inside); + } + if (!data || data.inside) { + this.canvasInput.emit(type, event, this.inputValid); + } + } + + private emitPointerInput(event: FederatedPointerEvent, type = event.type): void { + if (!this.inputValid()) { + return; + } + // Native over/out represent logical transitions only, not sibling mark transitions. + if (type === 'pointerover' || type === 'pointerout' || type === 'pointerleave') { + const data = this.trackingData(event.pointerId); + if (data.previousInside !== data.inside) { + data.previousInside = data.inside; + this.emitBoundary(event, data.inside); + } + return; + } + this.emitInput(event, type); if (event.pointerType === 'touch') { - this.dispatchEvent(event, 'touchcancel'); + const alias = TOUCH_INPUT_TYPES[type]; + if (alias) { + this.emitInput(event, alias); + } + } else if (isMouseLike(event.pointerType)) { + const alias = + event.button === 2 && type === 'pointerdown' + ? 'rightdown' + : event.button === 2 && type === 'pointerup' + ? 'rightup' + : MOUSE_INPUT_TYPES[type]; + if (alias) { + this.emitInput(event, alias); + } + } + } + + protected onPointerCancel = (from: FederatedEvent): void => { + if (from instanceof FederatedPointerEvent) { + this.cancelPointer(from.pointerId); } - tracking.pressTargetsByButton = {}; - tracking.clicksByButton = {}; - this.freeEvent(event); - this.onPointerOut(from, target); }; addEventMapping(type: string, fn: (e: FederatedEvent, target: IEventTarget) => void): void { @@ -143,46 +319,92 @@ export class EventManager { } dispatchEvent(e: FederatedEvent, type?: string): void { + if (!this.inputValid()) { + return; + } + const previous = this.dispatchingEvent; + this.dispatchingEvent = e; e.propagationStopped = false; e.propagationImmediatelyStopped = false; - this.propagate(e, type); - this.dispatch.emit(type || e.type, e); + try { + this.propagate(e, type); + if (this.inputValid()) { + this.dispatch.emit(type || e.type, e); + } + } finally { + this.dispatchingEvent = previous; + } } - mapEvent(e: FederatedEvent): void { + mapEvent(e: FederatedEvent, inViewport = true): void { if (!this.rootTarget) { return; } - const mappers = this.mappingTable[e.type]; - - let target; - const cacheKey = `${e.canvasX}-${e.canvasY}`; - if ( - this._prePointTargetCache?.[cacheKey] && - (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage && - (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage.renderCount === - (this._prePointTargetCache?.stageRenderCount as number) - ) { - target = this._prePointTargetCache[cacheKey]; - } else { - target = this.pickTarget(e.viewX, e.viewY, e); - // 缓存上一个坐标点的拾取结果,减少拾取的次数,如 pointermove pointerdown 和 pointerup 在同一个点触发 - // 如果存在params,那么就不缓存 - if (!(e as any).pickParams) { - this._prePointTargetCache = { - [cacheKey]: target, - stageRenderCount: target?.stage.renderCount ?? -1 - }; - } + const previous = this.currentTracking; + const generation = this.currentGeneration; + const tracking = e instanceof FederatedPointerEvent ? this.trackingData(e.pointerId) : undefined; + this.currentTracking = tracking; + this.currentGeneration = tracking?.generation ?? 0; + if (tracking) { + tracking.previousInside = tracking.inside; + tracking.inside = inViewport; + tracking.pointerType = (e as FederatedPointerEvent).pointerType; + tracking.button = (e as FederatedPointerEvent).button; + tracking.canvasX = e.canvasX; + tracking.canvasY = e.canvasY; + tracking.viewX = e.viewX; + tracking.viewY = e.viewY; } + const type = e.type === 'pointerup' && !inViewport ? 'pointerupoutside' : e.type; + const mappers = this.mappingTable[type]; + try { + let target; + const cacheKey = `${e.canvasX}-${e.canvasY}`; + if (!inViewport) { + target = null; + } else if ( + this._prePointTargetCache?.[cacheKey] && + (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage && + (this._prePointTargetCache?.[cacheKey] as unknown as IGraphic)?.stage.renderCount === + (this._prePointTargetCache?.stageRenderCount as number) + ) { + target = this._prePointTargetCache[cacheKey]; + } else { + target = this.pickTarget(e.viewX, e.viewY, e); + // 缓存上一个坐标点的拾取结果,减少拾取的次数,如 pointermove pointerdown 和 pointerup 在同一个点触发 + // 如果存在params,那么就不缓存 + if (!(e as any).pickParams) { + this._prePointTargetCache = { + [cacheKey]: target, + stageRenderCount: target?.stage.renderCount ?? -1 + }; + } + } - if (mappers) { - for (let i = 0, j = mappers.length; i < j; i++) { - mappers[i].fn(e, target); + if (mappers) { + for (let i = 0, j = mappers.length; i < j && this.inputValid(); i++) { + mappers[i].fn(e, target); + } + } else { + Logger.getInstance().warn(`[EventManager]: Event mapping not defined for ${e.type}`); } - } else { - Logger.getInstance().warn(`[EventManager]: Event mapping not defined for ${e.type}`); + if ( + e instanceof FederatedPointerEvent && + type !== 'pointerup' && + type !== 'pointerupoutside' && + type !== 'pointercancel' + ) { + this.emitPointerInput(e); + } else if (e instanceof FederatedWheelEvent) { + this.emitInput(e); + } + } finally { + if (tracking) { + tracking.ending = undefined; + } + this.currentTracking = previous; + this.currentGeneration = generation; } } @@ -245,6 +467,10 @@ export class EventManager { } protected notifyTarget(e: FederatedEvent, type?: string): void { + if (!this.inputValid()) { + e.stopImmediatePropagation(); + return; + } if (this.pauseNotify) { return; } @@ -253,7 +479,7 @@ export class EventManager { this.notifyListeners(e, key); - if (e.eventPhase === e.AT_TARGET) { + if (e.eventPhase === e.AT_TARGET && this.inputValid() && !e.propagationImmediatelyStopped) { this.notifyListeners(e, type); } } @@ -267,6 +493,8 @@ export class EventManager { const e = this.createPointerEvent(from, from.type, target); + const trackingData = this.trackingData(from.pointerId); + trackingData.pressTargetsByButton[from.button] = e.composedPath(); this.dispatchEvent(e, 'pointerdown'); if (e.pointerType === 'touch') { @@ -277,10 +505,6 @@ export class EventManager { this.dispatchEvent(e, isRightButton ? 'rightdown' : 'mousedown'); } - const trackingData = this.trackingData(from.pointerId); - - trackingData.pressTargetsByButton[from.button] = e.composedPath(); - this.freeEvent(e); }; @@ -337,7 +561,7 @@ export class EventManager { let overTargetAncestor = outTarget?.parent; - while (overTargetAncestor && overTargetAncestor !== this.rootTarget.parent) { + while (this.inputValid() && overTargetAncestor && overTargetAncestor !== this.rootTarget.parent) { if (overTargetAncestor === e.target) { break; } @@ -345,7 +569,8 @@ export class EventManager { overTargetAncestor = overTargetAncestor.parent; } - const didPointerEnter = !overTargetAncestor || overTargetAncestor === this.rootTarget.parent; + const didPointerEnter = + this.inputValid() && (!overTargetAncestor || overTargetAncestor === this.rootTarget.parent); if (didPointerEnter) { const enterEvent = this.clonePointerEvent(e, 'pointerenter'); @@ -361,7 +586,12 @@ export class EventManager { ancestor = ancestor.parent; } - while (currentTarget && currentTarget !== outTarget && currentTarget !== this.rootTarget.parent) { + while ( + this.inputValid() && + currentTarget && + currentTarget !== outTarget && + currentTarget !== this.rootTarget.parent + ) { // 检查 currentTarget 是否是 outTarget 的祖先 if (!outTargetAncestors.has(currentTarget)) { enterEvent.currentTarget = currentTarget; @@ -389,13 +619,15 @@ export class EventManager { this[propagationMethod](e, 'touchmove'); } - if (isMouse) { + if (isMouse && this.inputValid()) { this[propagationMethod](e, 'mousemove'); this.cursorTarget = e.target; this.cursor = (e.target?.attribute?.cursor as Cursor) || this.rootTarget.getCursor(); } - trackingData.overTargets = e.composedPath(); + if (this.inputValid()) { + trackingData.overTargets = e.composedPath(); + } this.freeEvent(e); }; @@ -415,7 +647,7 @@ export class EventManager { if (isMouse) { this.dispatchEvent(e, 'mouseover'); } - if (e.pointerType === 'mouse') { + if (e.pointerType === 'mouse' && this.inputValid()) { this.cursorTarget = e.target; this.cursor = (e.target?.attribute?.cursor as Cursor) || this.rootTarget.getCursor(); } @@ -424,7 +656,7 @@ export class EventManager { enterEvent.eventPhase = enterEvent.AT_TARGET; - while (enterEvent.target && enterEvent.target !== this.rootTarget.parent) { + while (this.inputValid() && enterEvent.target && enterEvent.target !== this.rootTarget.parent) { enterEvent.currentTarget = enterEvent.target; this.notifyTarget(enterEvent); @@ -435,7 +667,9 @@ export class EventManager { enterEvent.target = enterEvent.target.parent as IEventTarget; } - trackingData.overTargets = e.composedPath(); + if (this.inputValid()) { + trackingData.overTargets = e.composedPath(); + } this.freeEvent(e); this.freeEvent(enterEvent); @@ -465,7 +699,7 @@ export class EventManager { leaveEvent.eventPhase = leaveEvent.AT_TARGET; - while (leaveEvent.target && leaveEvent.target !== this.rootTarget.parent) { + while (this.inputValid() && leaveEvent.target && leaveEvent.target !== this.rootTarget.parent) { leaveEvent.currentTarget = leaveEvent.target; this.notifyTarget(leaveEvent); @@ -496,6 +730,9 @@ export class EventManager { const now = clock.now(); const e = this.createPointerEvent(from, from.type, target); + const trackingData = this.trackingData(from.pointerId); + trackingData.ending = trackingData.pressTargetsByButton[from.button]; + delete trackingData.pressTargetsByButton[from.button]; this.dispatchEvent(e, 'pointerup'); if (e.pointerType === 'touch') { @@ -506,8 +743,7 @@ export class EventManager { this.dispatchEvent(e, isRightButton ? 'rightup' : 'mouseup'); } - const trackingData = this.trackingData(from.pointerId); - const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]); + const pressTarget = this.findMountedTarget(trackingData.ending); let clickTarget = pressTarget; @@ -535,7 +771,8 @@ export class EventManager { clickTarget = currentTarget; } - if (clickTarget) { + this.emitPointerInput(e, 'pointerup'); + if (clickTarget && this.inputValid()) { const clickEvent = this.clonePointerEvent(e, 'click'); clickEvent.target = clickTarget; @@ -567,20 +804,25 @@ export class EventManager { if (isMouseLike(clickEvent.pointerType)) { this.dispatchEvent(clickEvent, 'click'); + this.emitInput(clickEvent, 'click'); if (clickHistory.clickCount === 2) { // 双击 this.dispatchEvent(clickEvent, 'dblclick'); + this.emitInput(clickEvent, 'dblclick'); } } else if (clickEvent.pointerType === 'touch' && this._config.supportsTouchEvents) { this.dispatchEvent(clickEvent, 'tap'); + this.emitInput(clickEvent, 'tap'); if (clickHistory.clickCount === 2) { // 双击 this.dispatchEvent(clickEvent, 'dbltap'); + this.emitInput(clickEvent, 'dbltap'); } } this.dispatchEvent(clickEvent, 'pointertap'); + this.emitInput(clickEvent, 'pointertap'); this.freeEvent(clickEvent); } @@ -596,7 +838,9 @@ export class EventManager { } const trackingData = this.trackingData(from.pointerId); - const pressTarget = this.findMountedTarget(trackingData.pressTargetsByButton[from.button]); + trackingData.ending = trackingData.pressTargetsByButton[from.button]; + delete trackingData.pressTargetsByButton[from.button]; + const pressTarget = this.findMountedTarget(trackingData.ending); const e = this.createPointerEvent(from, from.type, target); if (pressTarget) { @@ -619,6 +863,7 @@ export class EventManager { delete trackingData.pressTargetsByButton[from.button]; } + this.emitPointerInput(e, 'pointerup'); this.freeEvent(e); }; @@ -776,6 +1021,9 @@ export class EventManager { protected trackingData(id: number): TrackingData { if (!this.mappingState.trackingData[id]) { this.mappingState.trackingData[id] = { + generation: 0, + inside: false, + previousInside: false, pressTargetsByButton: {}, clicksByButton: {}, overTarget: null @@ -802,6 +1050,11 @@ export class EventManager { } protected freeEvent(event: T): void { + event.nativeEvent = null; + event.originalEvent = null; + if (!this.rootTarget) { + return; + } if (event.manager !== this) { throw new Error('It is illegal to free an event not managed by this EventManager!'); } @@ -823,6 +1076,9 @@ export class EventManager { } private notifyListeners(e: FederatedEvent, type: string): void { + if (!this.inputValid() || !e.currentTarget) { + return; + } const events = (e.currentTarget as any)._events as EmitterListeners; const listeners = events[type]; @@ -833,7 +1089,7 @@ export class EventManager { } listeners.fn.call(listeners.context, e); } else { - for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) { + for (let i = 0, j = listeners.length; i < j && this.inputValid() && !e.propagationImmediatelyStopped; i++) { if (listeners[i].once) { e.currentTarget.removeEventListener(type, listeners[i].fn, { once: true }); } @@ -842,17 +1098,22 @@ export class EventManager { } } // 永远触发WILDCARD事件代理 - this.emitDelegation(e, type); + if (this.inputValid()) { + this.emitDelegation(e, type); + } } private emitDelegation(e: FederatedEvent, type: string): void { + if (!this.inputValid() || !e.currentTarget) { + return; + } const events = (e.currentTarget as any)._events as EmitterListeners; const listeners = events[WILDCARD]; if (listeners) { if ('fn' in listeners) { listeners.fn.call(listeners.context, e, type); } else { - for (let i = 0, j = listeners.length; i < j && !e.propagationImmediatelyStopped; i++) { + for (let i = 0, j = listeners.length; i < j && this.inputValid() && !e.propagationImmediatelyStopped; i++) { listeners[i].fn.call(listeners[i].context, e, type); } } @@ -885,7 +1146,10 @@ export class EventManager { this.eventPool.clear(); this.rootTarget = null; this.mappingTable = null; - this.mappingState = null; + this.mappingState = { trackingData: {} }; + this.canvasInput.clear(); + this.windowInput.clear(); + this.dispatchingEvent?.stopImmediatePropagation(); this.cursorTarget = null; } } diff --git a/packages/vrender-core/src/event/event-system.ts b/packages/vrender-core/src/event/event-system.ts index 252f347f2..de58dd758 100644 --- a/packages/vrender-core/src/event/event-system.ts +++ b/packages/vrender-core/src/event/event-system.ts @@ -10,7 +10,7 @@ import type { IEventTarget, NativeEvent, RenderConfig, - INativeEventOptions + HostInputOptions } from '../interface/event'; import { clock } from './util'; @@ -97,7 +97,7 @@ export class EventSystem { private rootPointerEvent: FederatedPointerEvent; private rootWheelEvent: FederatedWheelEvent; private eventsAdded: boolean; - private readonly nativeEvents: boolean; + private readonly useNativeEvents: boolean; constructor(params: RenderConfig) { const { @@ -132,18 +132,25 @@ export class EventSystem { pointer: 'pointer' }; - this.nativeEvents = params.nativeEvents !== false; + this.useNativeEvents = params.useNativeEvents !== false; this.resolution = resolution; this.setTargetElement(targetElement); } release(): void { - this.setNativeEventOptions(); - this.removeEvents(); - this.manager && this.manager.release(); - this.domElement = null; - (this as any).manager = null; - (this as any).globalObj = null; + if (this.released) { + return; + } + this.released = true; + this.pendingInputs = undefined; + try { + this.manager.cancelAllPointers(); + } finally { + this.removeEvents(); + this.manager.release(); + this.domElement = null; + (this as any).globalObj = null; + } } setCursor(mode: string, target: IEventTarget | null | 'ignore'): void { @@ -174,235 +181,127 @@ export class EventSystem { } } - private nativeEventBinding?: { reset(): void; release(): void }; + /** The window scope is this Stage's accepted input, not the browser's unfiltered window. */ + get input() { + return this.manager.input; + } + + private released = false; + private processingInput = false; + private pendingInputs?: { event: NativeEvent | WheelEvent; options?: HostInputOptions }[]; - /** Bind a DOM input source independently from the render canvas. Filtering precedes pointer state updates. */ - setNativeEventOptions(options?: INativeEventOptions): void { - this.nativeEventBinding?.release(); - this.nativeEventBinding = undefined; - if (!options) { + /** Ignoring an input and cancelling a gesture are separate host decisions. */ + handleNativeEvent(event: NativeEvent | WheelEvent, options?: HostInputOptions): void { + if (this.released) { return; } - const system = this; - const { manager } = system; - const originalTarget = system.domElement; - const originalMap = system.mapToCanvasPoint; - const lastEvents = new Map(); - let released = false; - system.removeEvents(); - system.domElement = options.target; - system.mapToCanvasPoint = event => options.mapPoint(event as PointerEvent); - - const reset = (pointerId?: number) => { - lastEvents.forEach((input, id) => { - if (pointerId !== undefined && pointerId !== id) { - return; - } - lastEvents.delete(id); - // Cancellation, unlike rejection, must reach the old target and logical canvas listeners. - const event = system.bootstrapEvent(system.rootPointerEvent, input); - event.type = 'pointercancel'; - event.nativeEvent = null; - manager.mapEvent(event); - }); - }; - const receiveInput = (nativeEvent: Event) => { - if (released) { - return; - } - const target = nativeEvent.composedPath?.()[0] ?? nativeEvent.target; - if (target !== options.target || !options.filter(nativeEvent as MouseEvent)) { - if (lastEvents.size) { - reset((nativeEvent as PointerEvent).pointerId ?? 1); - } - return; - } - if (nativeEvent.type === 'wheel') { - manager.mapEvent(system.normalizeWheelEvent(nativeEvent as WheelEvent)); - return; - } - const normalized = system.normalizeToPointerData(nativeEvent as NativeEvent); - normalized.forEach(input => { - const event = system.bootstrapEvent(system.rootPointerEvent, input); - lastEvents.delete(event.pointerId); - try { - manager.mapEvent(event); - if ( - !released && - event.type !== 'pointercancel' && - event.type !== 'pointerleave' && - event.type !== 'pointerout' - ) { - // Retain only active input; pooled federated events are reused by the engine. - lastEvents.set(event.pointerId, input); - } - if (!released) { - options.onCursor(manager.cursor || 'default'); - } - } finally { - system.rootPointerEvent.nativeEvent = null; + if (this.processingInput) { + // Allocate only for reentrant input. Finish the old transaction before starting a new gesture. + (this.pendingInputs ??= []).push({ + event, + options: options && { + canvasPoint: { x: options.canvasPoint.x, y: options.canvasPoint.y }, + inViewport: options.inViewport } }); - }; - const handleError = (error: unknown) => { - if (options.onError) { - options.onError(error); - } else { - throw error; - } - }; - const receive = (event: Event) => { - try { - receiveInput(event); - } catch (error) { - handleError(error); - } - }; - const types = options.pointerEvents - ? ['pointerdown', 'pointermove', 'pointerup', 'pointercancel'] - : ['mousedown', 'mousemove', 'mouseup', 'pointercancel']; - // Host arbitration runs first on this root/phase; rejected input never reaches the pointer state machine. - types.forEach(type => options.root.addEventListener(type, receive)); - options.target.addEventListener('wheel', receive); - const leave = () => { - try { - reset(); - } catch (error) { - handleError(error); - } - }; - options.target.addEventListener(options.pointerEvents ? 'pointerleave' : 'mouseleave', leave); - const view = options.target.ownerDocument.defaultView; - view?.addEventListener('blur', leave); - - this.nativeEventBinding = { - reset, - release() { - if (released) { - return; - } - released = true; - types.forEach(type => options.root.removeEventListener(type, receive)); - options.target.removeEventListener('wheel', receive); - options.target.removeEventListener(options.pointerEvents ? 'pointerleave' : 'mouseleave', leave); - view?.removeEventListener('blur', leave); - reset(); - system.domElement = originalTarget; - system.mapToCanvasPoint = originalMap; - } - }; - } - - resetNativeEvents(): void { - this.nativeEventBinding?.reset(); - } - - private onPointerDown = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { return; } - - const events = this.normalizeToPointerData(nativeEvent); - - if (this.autoPreventDefault && (events[0] as any).isNormalized) { - const cancelable = nativeEvent.cancelable || !('cancelable' in nativeEvent); - - if (cancelable) { - nativeEvent.preventDefault(); - } + this.processingInput = true; + try { + this.processInput(event, options); + this.drainInputQueue(); + } finally { + this.processingInput = false; + this.pendingInputs = undefined; + this.rootPointerEvent.nativeEvent = null; + this.rootWheelEvent.nativeEvent = null; } + } - for (let i = 0, j = events.length; i < j; i++) { - const nativeEvent = events[i]; - const federatedEvent = this.bootstrapEvent(this.rootPointerEvent, nativeEvent); - - this.manager.mapEvent(federatedEvent); - } + cancelPointer(pointerId: number): void { + this.cancelInput(pointerId); + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; + cancelAllPointers(): void { + this.cancelInput(); + } - private onPointerMove = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + private cancelInput(pointerId?: number): void { + if (this.released) { return; } - - if (this.isEventOutsideOfTargetElement(nativeEvent)) { - return; + const processing = this.processingInput; + this.processingInput = true; + try { + if (pointerId === undefined) { + this.manager.cancelAllPointers(); + } else { + this.manager.cancelPointer(pointerId); + } + if (!processing) { + this.drainInputQueue(); + } + } finally { + this.processingInput = processing; + if (!processing) { + this.pendingInputs = undefined; + this.rootPointerEvent.nativeEvent = null; + this.rootWheelEvent.nativeEvent = null; + } } + } - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - for (let i = 0, j = normalizedEvents.length; i < j; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - - this.manager.mapEvent(event); + private drainInputQueue(): void { + while (!this.released && this.pendingInputs?.length) { + const next = this.pendingInputs.shift(); + this.processInput(next.event, next.options); } + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; - - private onPointerUp = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + private processInput(nativeEvent: NativeEvent | WheelEvent, options?: HostInputOptions): void { + if (!options && this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { return; } - - const outside = this.isEventOutsideOfTargetViewPort(nativeEvent) ? 'outside' : ''; - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - - for (let i = 0, j = normalizedEvents.length; i < j; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - - event.type += outside; - - this.manager.mapEvent(event); - } - - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; - - private onPointerCancel = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { + if (nativeEvent.type === 'wheel') { + const event = this.normalizeWheelEvent(nativeEvent as WheelEvent, options?.canvasPoint); + if (options?.inViewport ?? !this.isEventOutsideOfTargetViewPort(nativeEvent, event)) { + this.manager.mapEvent(event); + } return; } - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - for (let i = 0; i < normalizedEvents.length; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - event.type = 'pointercancel'; - this.manager.mapEvent(event); - } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - this.rootPointerEvent.nativeEvent = null; - }; - - private onPointerOverOut = (nativeEvent: NativeEvent): void => { - if (this.supportsTouchEvents && (nativeEvent as PointerEvent).pointerType === 'touch') { - return; + const events = this.normalizeToPointerData(nativeEvent); + if (this.autoPreventDefault && (events[0] as VRenderPointerEvent)?.isNormalized && nativeEvent.cancelable) { + nativeEvent.preventDefault(); + } + for (let i = 0; i < events.length && !this.released; i++) { + const event = this.bootstrapEvent(this.rootPointerEvent, events[i], options?.canvasPoint); + // Keep the original TouchEvent so synchronous preventDefault reaches the browser. + event.nativeEvent = nativeEvent; + if (event.type === 'pointercancel') { + this.manager.cancelPointer(event.pointerId); + continue; + } + const inside = + event.type !== 'pointerout' && + event.type !== 'pointerleave' && + (options?.inViewport ?? !this.isEventOutsideOfTargetViewPort(nativeEvent, event)); + if (!inside && (event.type === 'pointerdown' || !this.manager.hasPointer(event.pointerId))) { + continue; + } + this.manager.mapEvent(event, inside); } - - const normalizedEvents = this.normalizeToPointerData(nativeEvent); - - for (let i = 0, j = normalizedEvents.length; i < j; i++) { - const event = this.bootstrapEvent(this.rootPointerEvent, normalizedEvents[i]); - - this.manager.mapEvent(event); + if (!options && !this.released) { + this.setCursor(this.manager.cursor, this.manager.cursorTarget); } + } - this.setCursor(this.manager.cursor, this.manager.cursorTarget); - // 避免内存泄露 - this.rootPointerEvent.nativeEvent = null; - }; - - protected onWheel = (nativeEvent: WheelEvent): void => { - const wheelEvent = this.normalizeWheelEvent(nativeEvent); - - this.manager.mapEvent(wheelEvent); - }; + private onPointerDown = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerMove = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerUp = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerCancel = (event: NativeEvent): void => this.handleNativeEvent(event); + private onPointerOverOut = (event: NativeEvent): void => this.handleNativeEvent(event); + protected onWheel = (event: WheelEvent): void => this.handleNativeEvent(event); + private onBlur = (): void => this.cancelAllPointers(); setTargetElement(element: IElementLike | null): void { this.removeEvents(); @@ -411,7 +310,7 @@ export class EventSystem { } private addEvents(): void { - if (!this.nativeEvents || this.eventsAdded || !this.domElement) { + if (!this.useNativeEvents || this.eventsAdded || !this.domElement) { return; } const { globalObj, domElement } = this; @@ -446,13 +345,14 @@ export class EventSystem { domElement.addEventListener('touchstart', this.onPointerDown, true); domElement.addEventListener('touchend', this.onPointerUp, true); domElement.addEventListener('touchcancel', this.onPointerCancel, true); - domElement.addEventListener('touchmove', this.onPointerMove, true); + domElement.addEventListener('touchmove', this.onPointerMove, { capture: true, passive: false }); } domElement.addEventListener('wheel', this.onWheel, { capture: true }); + globalObj.getDocument?.()?.defaultView?.addEventListener('blur', this.onBlur); this.eventsAdded = true; } @@ -461,6 +361,7 @@ export class EventSystem { return; } const { globalObj, domElement } = this; + globalObj.getDocument?.()?.defaultView?.removeEventListener('blur', this.onBlur); // const globalDocument = globalObj.getDocument() ?? domElement; if (this.supportsPointerEvents) { @@ -639,7 +540,7 @@ export class EventSystem { return normalizedEvents as PointerEvent[]; } - protected normalizeWheelEvent(nativeEvent: WheelEvent): FederatedWheelEvent { + protected normalizeWheelEvent(nativeEvent: WheelEvent, canvasPoint?: EventPoint): FederatedWheelEvent { const event = this.rootWheelEvent; this.transferMouseData(event, nativeEvent); @@ -650,7 +551,7 @@ export class EventSystem { event.deltaZ = nativeEvent.deltaZ; // 获取相对画布坐标 - const { x: canvasX, y: canvasY } = this.mapToCanvasPoint(nativeEvent); + const { x: canvasX, y: canvasY } = canvasPoint ?? this.mapToCanvasPoint(nativeEvent); event.canvas.x = canvasX; event.canvas.y = canvasY; @@ -676,7 +577,11 @@ export class EventSystem { * @param event * @param nativeEvent */ - private bootstrapEvent(event: FederatedPointerEvent, nativeEvent: PointerEvent): FederatedPointerEvent { + private bootstrapEvent( + event: FederatedPointerEvent, + nativeEvent: PointerEvent, + canvasPoint?: EventPoint + ): FederatedPointerEvent { event.originalEvent = null; event.nativeEvent = nativeEvent; @@ -692,7 +597,7 @@ export class EventSystem { event.twist = nativeEvent.twist; this.transferMouseData(event, nativeEvent); - const { x: canvasX, y: canvasY } = this.mapToCanvasPoint(nativeEvent); + const { x: canvasX, y: canvasY } = canvasPoint ?? this.mapToCanvasPoint(nativeEvent); event.canvas.x = canvasX; event.canvas.y = canvasY; @@ -747,14 +652,14 @@ export class EventSystem { event.relatedTarget = null; } - private isEventOutsideOfTargetViewPort(nativeEvent: NativeEvent) { + private isEventOutsideOfTargetViewPort(nativeEvent: NativeEvent, event: FederatedMouseEvent) { if (this.isEventOutsideOfTargetElement(nativeEvent)) { return true; } // 判断点是否在区间内 if ((this.domElement as IWindow).getViewBox) { - const p = this.mapToViewportPoint(this.mapToCanvasPoint(nativeEvent as any)); + const p = event.viewport; const b = (this.domElement as IWindow).getViewBox(); const w = b.width(); const h = b.height(); diff --git a/packages/vrender-core/src/event/input-source.ts b/packages/vrender-core/src/event/input-source.ts new file mode 100644 index 000000000..7846ad8cd --- /dev/null +++ b/packages/vrender-core/src/event/input-source.ts @@ -0,0 +1,39 @@ +import type { IFederatedMouseEvent, InputEventSource } from '../interface/event'; + +type Listener = (event: IFederatedMouseEvent) => void; + +/** Copy-on-write subscriptions: dispatch allocates nothing and cancellation can stop remaining listeners. */ +export class InputSource { + private listeners: Record = {}; + readonly source: InputEventSource = { + on: (type, listener) => { + this.listeners[type] = (this.listeners[type] ?? []).concat(listener); + }, + off: (type, listener) => { + const list = this.listeners[type]; + if (list) { + this.listeners[type] = list.filter(fn => fn !== listener); + } + } + }; + + emit(type: string, event: IFederatedMouseEvent, valid: () => boolean): void { + const list = this.listeners[type]; + if (!list) { + return; + } + const originalType = event.type; + event.type = type; + try { + for (let i = 0; i < list.length && valid(); i++) { + list[i](event); + } + } finally { + event.type = originalType; + } + } + + clear(): void { + this.listeners = {}; + } +} diff --git a/packages/vrender-core/src/interface/event.ts b/packages/vrender-core/src/interface/event.ts index 864958e94..0802bd0ba 100644 --- a/packages/vrender-core/src/interface/event.ts +++ b/packages/vrender-core/src/interface/event.ts @@ -214,7 +214,7 @@ export type IElementLike = Omit void): void; + off(type: string, listener: (event: IFederatedMouseEvent) => void): void; } diff --git a/packages/vrender-core/src/interface/stage.ts b/packages/vrender-core/src/interface/stage.ts index 1dcc816e8..229639a3f 100644 --- a/packages/vrender-core/src/interface/stage.ts +++ b/packages/vrender-core/src/interface/stage.ts @@ -62,8 +62,8 @@ export interface IStageParams { disableDirtyBounds: boolean; // 是否支持独立交互 Layer,默认为 true。 interactiveLayer: boolean; - /** 交互层的渲染模式;缺省沿用环境默认,virtual 复用主层 Canvas。 */ - interactiveLayerMode?: LayerMode; + /** 交互层的渲染模式;缺省沿用环境默认,virtual 复用主层 Canvas,在首帧准备前创建。 */ + interactiveLayerMode?: 'static' | 'virtual'; /** Delegate invalidation to an external compositor; paint explicitly with renderTo. */ requestRender?: () => void; // 是否支持HTML属性 @@ -111,8 +111,8 @@ export interface IStageParams { } export type EventConfig = { - /** 保留事件管理器,由外部输入事件,不监听共享 Canvas/Window。 */ - nativeEvents?: boolean; + /** 设为 false 时保留事件管理器,由宿主输入事件,不绑定默认 DOM 监听。 */ + useNativeEvents?: boolean; /** 是否自动阻止事件 */ autoPreventDefault?: boolean; /** From 79b4bf251065f91be3fde95cd962937c93ae6b0b Mon Sep 17 00:00:00 2001 From: "chendaxin.tk" Date: Thu, 29 Oct 2026 17:18:23 +0800 Subject: [PATCH 8/9] fix: preserve host clipping and pointer cancellation isolation --- .../__tests__/util/host-input.js | 73 +++++++++++++++++++ .../smoke/stage-interactive-layer.test.ts | 9 ++- .../vrender-core/src/event/event-manager.ts | 6 +- 3 files changed, 84 insertions(+), 4 deletions(-) diff --git a/packages/vrender-components/__tests__/util/host-input.js b/packages/vrender-components/__tests__/util/host-input.js index 287b4b471..15ae82bce 100644 --- a/packages/vrender-components/__tests__/util/host-input.js +++ b/packages/vrender-components/__tests__/util/host-input.js @@ -66,6 +66,79 @@ export async function runHostInputChecks() { results = []; loadBrowserEnv(); vglobal.setEnv('browser'); + // A clipped point must not trigger another scenegraph pick. + for (const affine of [false, true]) { + const rect = createRect({ x: 10, y: 10, width: 60, height: 60, fill: 'red' }); + const a = setup(rect); + const b = createRect({ x: 100, y: 10, width: 60, height: 60, fill: 'blue' }); + a.stage.defaultLayer.add(b); + a.stage.render(); + let hits = 0, + outsideMoves = 0, + leaves = 0; + for (const type of ['pointerover', 'pointerenter', 'pointermove', 'mousemove']) b.on(type, () => hits++); + rect.on('pointerout', () => leaves++); + a.sys.input.window.on('pointermove', () => outsideMoves++); + const send = (type, x, inside) => { + const client = affine ? { x: 1.5 * x + 46, y: 0.2 * x + 36 } : { x, y: 20 }; + a.sys.handleNativeEvent( + new PointerEvent(type, { + clientX: client.x, + clientY: client.y, + pointerId: 1, + pointerType: 'mouse', + buttons: 1 + }), + { canvasPoint: { x, y: 20 }, inViewport: inside } + ); + }; + send('pointermove', 20, true); + send('pointerdown', 20, true); + send('pointermove', 120, false); + check('host-clipped-target-' + affine, hits === 0 && outsideMoves === 2 && leaves === 1, { + hits, + outsideMoves, + leaves + }); + a.release(); + } + for (const capture of [true, false]) { + const rect = createRect({ x: 10, y: 10, width: 60, height: 60, fill: 'red' }); + const a = setup(rect); + let later = 0, + cancelled = 0, + scoped = 0; + const cancelOther = e => { + if (e.pointerId === 7) a.sys.cancelPointer(19); + }; + (capture ? a.stage : rect).addEventListener('pointerdown', cancelOther, capture); + rect.on('pointerdown', e => { + if (e.pointerId === 7) later++; + }); + a.sys.input.window.on('pointercancel', e => { + if (e.pointerId === 19) cancelled++; + }); + a.sys.input.window.on('pointerdown', e => { + if (e.pointerId === 7) scoped++; + }); + for (const id of [19, 7]) + a.sys.handleNativeEvent( + new PointerEvent('pointerdown', { + pointerId: id, + pointerType: 'touch', + clientX: 20, + clientY: 20, + buttons: 1 + }), + { canvasPoint: { x: 20, y: 20 }, inViewport: true } + ); + check('cancel-other-pointer-' + capture, later === 1 && cancelled === 1 && scoped === 1, { + later, + cancelled, + scoped + }); + a.release(); + } for (const defaults of [false, true]) { const a = setup(createRect({ x: 10, y: 10, width: 100, height: 100, fill: 'red' }), defaults); let clicks = 0, diff --git a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts index 5600d9d70..b58736a30 100644 --- a/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts +++ b/packages/vrender-core/__tests__/unit/smoke/stage-interactive-layer.test.ts @@ -3,6 +3,7 @@ import { createNodeSmokeStage } from './node-smoke-stage'; import { registerGroupGraphic } from '../../../src/register/register-group'; import { registerShadowRootGraphic } from '../../../src/register/register-shadowRoot'; import { createRect } from '../../../src/graphic/rect'; +import { EmptyLayerHandlerContribution } from '../../../src/core/contributions/layerHandler/empty-contribution'; import type { IStageParams } from '../../../src/interface'; describe('interactive layer mode', () => { @@ -21,7 +22,7 @@ describe('interactive layer mode', () => { height: 100, autoRender: false, autoRefresh: false, - event: false, + event: { useNativeEvents: false }, ...options }); try { @@ -32,7 +33,11 @@ describe('interactive layer mode', () => { if (layer) { expect(layer.layerMode).toBe('virtual'); expect(layer.parent).toBe(stage); - expect(layer.getNativeHandler().canvas).toBeNull(); + const handler = layer.getNativeHandler(); + expect(handler).toBeInstanceOf(EmptyLayerHandlerContribution); + if (handler instanceof EmptyLayerHandlerContribution) { + expect(handler.canvas).toBeNull(); + } const rect = createRect({ x: 10, y: 10, width: 20, height: 20, fill: 'red', globalZIndex: 1 }); stage.defaultLayer.add(rect); stage.render(); diff --git a/packages/vrender-core/src/event/event-manager.ts b/packages/vrender-core/src/event/event-manager.ts index db8036628..6ca52ec40 100644 --- a/packages/vrender-core/src/event/event-manager.ts +++ b/packages/vrender-core/src/event/event-manager.ts @@ -187,7 +187,9 @@ export class EventManager { data.ending = undefined; data.inside = false; data.overTargets = []; - this.dispatchingEvent?.stopImmediatePropagation(); + if (this.dispatchingEvent instanceof FederatedPointerEvent && this.dispatchingEvent.pointerId === id) { + this.dispatchingEvent.stopImmediatePropagation(); + } const event = this.allocateEvent(FederatedPointerEvent); event.type = 'pointercancel'; event.pointerId = id; @@ -912,7 +914,7 @@ export class EventManager { event.nativeEvent = from.nativeEvent; event.originalEvent = from; - if (target) { + if (target !== undefined) { event.target = target; } else { event.target = this.pickTarget(event.viewX ?? event.global.x, event.viewY ?? event.global.y, event); From fed2ed262030cfcb8225b8eda06c2438b2d18259 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 30 Oct 2026 02:36:14 +0000 Subject: [PATCH 9/9] build: prelease version 1.1.13 --- common/config/rush/pnpm-lock.yaml | 36 ++++++++++----------- common/config/rush/version-policies.json | 2 +- docs/package.json | 2 +- packages/react-vrender-utils/CHANGELOG.json | 6 ++++ packages/react-vrender-utils/CHANGELOG.md | 7 +++- packages/react-vrender-utils/package.json | 6 ++-- packages/react-vrender/CHANGELOG.json | 6 ++++ packages/react-vrender/CHANGELOG.md | 7 +++- packages/react-vrender/package.json | 4 +-- packages/vrender-animate/CHANGELOG.json | 6 ++++ packages/vrender-animate/CHANGELOG.md | 7 +++- packages/vrender-animate/package.json | 4 +-- packages/vrender-components/CHANGELOG.json | 6 ++++ packages/vrender-components/CHANGELOG.md | 7 +++- packages/vrender-components/package.json | 8 ++--- packages/vrender-core/CHANGELOG.json | 6 ++++ packages/vrender-core/CHANGELOG.md | 7 +++- packages/vrender-core/package.json | 2 +- packages/vrender-kits/CHANGELOG.json | 6 ++++ packages/vrender-kits/CHANGELOG.md | 7 +++- packages/vrender-kits/package.json | 4 +-- packages/vrender/CHANGELOG.json | 6 ++++ packages/vrender/CHANGELOG.md | 7 +++- packages/vrender/package.json | 10 +++--- tools/bugserver-trigger/package.json | 10 +++--- 25 files changed, 128 insertions(+), 51 deletions(-) diff --git a/common/config/rush/pnpm-lock.yaml b/common/config/rush/pnpm-lock.yaml index 1ccef0117..7def3eaf8 100644 --- a/common/config/rush/pnpm-lock.yaml +++ b/common/config/rush/pnpm-lock.yaml @@ -22,7 +22,7 @@ importers: specifier: ~0.5.7 version: 0.5.7 '@visactor/vrender': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../packages/vrender '@visactor/vutils': specifier: ~1.0.12 @@ -95,7 +95,7 @@ importers: ../../packages/react-vrender: dependencies: '@visactor/vrender': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender '@visactor/vutils': specifier: ~1.0.12 @@ -168,10 +168,10 @@ importers: ../../packages/react-vrender-utils: dependencies: '@visactor/react-vrender': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../react-vrender '@visactor/vrender': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender '@visactor/vutils': specifier: ~1.0.12 @@ -241,16 +241,16 @@ importers: ../../packages/vrender: dependencies: '@visactor/vrender-animate': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-animate '@visactor/vrender-components': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-components '@visactor/vrender-core': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-core '@visactor/vrender-kits': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-kits devDependencies: '@internal/bundler': @@ -320,7 +320,7 @@ importers: ../../packages/vrender-animate: dependencies: '@visactor/vrender-core': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-core '@visactor/vutils': specifier: ~1.0.12 @@ -393,13 +393,13 @@ importers: ../../packages/vrender-components: dependencies: '@visactor/vrender-animate': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-animate '@visactor/vrender-core': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-core '@visactor/vrender-kits': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-kits '@visactor/vscale': specifier: ~1.0.12 @@ -518,7 +518,7 @@ importers: specifier: 2.4.1 version: 2.4.1 '@visactor/vrender-core': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../vrender-core '@visactor/vutils': specifier: ~1.0.12 @@ -649,19 +649,19 @@ importers: ../../tools/bugserver-trigger: dependencies: '@visactor/vrender': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../../packages/vrender '@visactor/vrender-animate': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../../packages/vrender-animate '@visactor/vrender-components': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../../packages/vrender-components '@visactor/vrender-core': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../../packages/vrender-core '@visactor/vrender-kits': - specifier: workspace:1.1.12 + specifier: workspace:1.1.13 version: link:../../packages/vrender-kits devDependencies: '@internal/bundler': diff --git a/common/config/rush/version-policies.json b/common/config/rush/version-policies.json index ef5b55c90..2a960c877 100644 --- a/common/config/rush/version-policies.json +++ b/common/config/rush/version-policies.json @@ -1 +1 @@ -[{"definitionName":"lockStepVersion","policyName":"vrenderMain","version":"1.1.12","nextBump":"patch"}] +[{"definitionName":"lockStepVersion","policyName":"vrenderMain","version":"1.1.13","nextBump":"patch"}] diff --git a/docs/package.json b/docs/package.json index 3530cd1a1..6ecb1c511 100644 --- a/docs/package.json +++ b/docs/package.json @@ -13,7 +13,7 @@ "@visactor/vchart": "1.3.0", "@visactor/vutils": "~1.0.12", "@visactor/vgrammar": "~0.5.7", - "@visactor/vrender": "workspace:1.1.12", + "@visactor/vrender": "workspace:1.1.13", "markdown-it": "^13.0.0", "highlight.js": "^11.8.0", "axios": "^1.4.0", diff --git a/packages/react-vrender-utils/CHANGELOG.json b/packages/react-vrender-utils/CHANGELOG.json index 83f42aa5b..5416836f9 100644 --- a/packages/react-vrender-utils/CHANGELOG.json +++ b/packages/react-vrender-utils/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/react-vrender-utils", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/react-vrender-utils_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/react-vrender-utils_v1.1.12", diff --git a/packages/react-vrender-utils/CHANGELOG.md b/packages/react-vrender-utils/CHANGELOG.md index 94ccfe291..fa97cba59 100644 --- a/packages/react-vrender-utils/CHANGELOG.md +++ b/packages/react-vrender-utils/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/react-vrender-utils -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:49 GMT diff --git a/packages/react-vrender-utils/package.json b/packages/react-vrender-utils/package.json index afb12c8dd..50ec0b073 100644 --- a/packages/react-vrender-utils/package.json +++ b/packages/react-vrender-utils/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/react-vrender-utils", - "version": "1.1.12", + "version": "1.1.13", "description": "", "sideEffects": false, "main": "cjs/index.js", @@ -27,8 +27,8 @@ "react-dom": "^18.2.0" }, "dependencies": { - "@visactor/vrender": "workspace:1.1.12", - "@visactor/react-vrender": "workspace:1.1.12", + "@visactor/vrender": "workspace:1.1.13", + "@visactor/react-vrender": "workspace:1.1.13", "@visactor/vutils": "~1.0.12", "react-reconciler": "^0.29.0", "tslib": "^2.3.1" diff --git a/packages/react-vrender/CHANGELOG.json b/packages/react-vrender/CHANGELOG.json index a42683918..a9d0e6ff1 100644 --- a/packages/react-vrender/CHANGELOG.json +++ b/packages/react-vrender/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/react-vrender", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/react-vrender_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/react-vrender_v1.1.12", diff --git a/packages/react-vrender/CHANGELOG.md b/packages/react-vrender/CHANGELOG.md index 9474877cd..e35470614 100644 --- a/packages/react-vrender/CHANGELOG.md +++ b/packages/react-vrender/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/react-vrender -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:48 GMT diff --git a/packages/react-vrender/package.json b/packages/react-vrender/package.json index 3e1536308..1478d2478 100644 --- a/packages/react-vrender/package.json +++ b/packages/react-vrender/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/react-vrender", - "version": "1.1.12", + "version": "1.1.13", "description": "", "sideEffects": false, "main": "cjs/index.js", @@ -26,7 +26,7 @@ "react": "^18.2.0" }, "dependencies": { - "@visactor/vrender": "workspace:1.1.12", + "@visactor/vrender": "workspace:1.1.13", "@visactor/vutils": "~1.0.12", "react-reconciler": "^0.29.0", "tslib": "^2.3.1" diff --git a/packages/vrender-animate/CHANGELOG.json b/packages/vrender-animate/CHANGELOG.json index dbea8dd6c..75c252252 100644 --- a/packages/vrender-animate/CHANGELOG.json +++ b/packages/vrender-animate/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/vrender-animate", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/vrender-animate_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/vrender-animate_v1.1.12", diff --git a/packages/vrender-animate/CHANGELOG.md b/packages/vrender-animate/CHANGELOG.md index 4128853be..492af119c 100644 --- a/packages/vrender-animate/CHANGELOG.md +++ b/packages/vrender-animate/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/vrender-animate -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:49 GMT diff --git a/packages/vrender-animate/package.json b/packages/vrender-animate/package.json index 7195ada1c..2b95b8c59 100644 --- a/packages/vrender-animate/package.json +++ b/packages/vrender-animate/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/vrender-animate", - "version": "1.1.12", + "version": "1.1.13", "description": "", "sideEffects": false, "main": "cjs/index.js", @@ -37,7 +37,7 @@ }, "dependencies": { "@visactor/vutils": "~1.0.12", - "@visactor/vrender-core": "workspace:1.1.12" + "@visactor/vrender-core": "workspace:1.1.13" }, "devDependencies": { "@internal/bundler": "workspace:*", diff --git a/packages/vrender-components/CHANGELOG.json b/packages/vrender-components/CHANGELOG.json index 0480221f9..5a43d220f 100644 --- a/packages/vrender-components/CHANGELOG.json +++ b/packages/vrender-components/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/vrender-components", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/vrender-components_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/vrender-components_v1.1.12", diff --git a/packages/vrender-components/CHANGELOG.md b/packages/vrender-components/CHANGELOG.md index 0fe9877c3..062083bd9 100644 --- a/packages/vrender-components/CHANGELOG.md +++ b/packages/vrender-components/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/vrender-components -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:49 GMT diff --git a/packages/vrender-components/package.json b/packages/vrender-components/package.json index 2e2e260a1..186a01b17 100644 --- a/packages/vrender-components/package.json +++ b/packages/vrender-components/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/vrender-components", - "version": "1.1.12", + "version": "1.1.13", "description": "components library for dp visualization", "sideEffects": false, "main": "cjs/index.js", @@ -69,9 +69,9 @@ "dependencies": { "@visactor/vutils": "~1.0.12", "@visactor/vscale": "~1.0.12", - "@visactor/vrender-core": "workspace:1.1.12", - "@visactor/vrender-kits": "workspace:1.1.12", - "@visactor/vrender-animate": "workspace:1.1.12" + "@visactor/vrender-core": "workspace:1.1.13", + "@visactor/vrender-kits": "workspace:1.1.13", + "@visactor/vrender-animate": "workspace:1.1.13" }, "devDependencies": { "@internal/bundler": "workspace:*", diff --git a/packages/vrender-core/CHANGELOG.json b/packages/vrender-core/CHANGELOG.json index 84c5fd828..0576b364e 100644 --- a/packages/vrender-core/CHANGELOG.json +++ b/packages/vrender-core/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/vrender-core", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/vrender-core_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/vrender-core_v1.1.12", diff --git a/packages/vrender-core/CHANGELOG.md b/packages/vrender-core/CHANGELOG.md index 5b2f349c8..23dc8e5e5 100644 --- a/packages/vrender-core/CHANGELOG.md +++ b/packages/vrender-core/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/vrender-core -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:49 GMT diff --git a/packages/vrender-core/package.json b/packages/vrender-core/package.json index 6b338d04d..13039fdf6 100644 --- a/packages/vrender-core/package.json +++ b/packages/vrender-core/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/vrender-core", - "version": "1.1.12", + "version": "1.1.13", "description": "", "sideEffects": [ "./src/modules.ts", diff --git a/packages/vrender-kits/CHANGELOG.json b/packages/vrender-kits/CHANGELOG.json index dd0681514..75ae43640 100644 --- a/packages/vrender-kits/CHANGELOG.json +++ b/packages/vrender-kits/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/vrender-kits", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/vrender-kits_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/vrender-kits_v1.1.12", diff --git a/packages/vrender-kits/CHANGELOG.md b/packages/vrender-kits/CHANGELOG.md index bafa78c2c..7ed85cf13 100644 --- a/packages/vrender-kits/CHANGELOG.md +++ b/packages/vrender-kits/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/vrender-kits -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:49 GMT diff --git a/packages/vrender-kits/package.json b/packages/vrender-kits/package.json index bdad14ed1..2e9349f99 100644 --- a/packages/vrender-kits/package.json +++ b/packages/vrender-kits/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/vrender-kits", - "version": "1.1.12", + "version": "1.1.13", "description": "", "sideEffects": false, "main": "cjs/index-node.js", @@ -38,7 +38,7 @@ }, "dependencies": { "@visactor/vutils": "~1.0.12", - "@visactor/vrender-core": "workspace:1.1.12", + "@visactor/vrender-core": "workspace:1.1.13", "@resvg/resvg-js": "2.4.1", "roughjs": "4.6.6", "gifuct-js": "2.1.2", diff --git a/packages/vrender/CHANGELOG.json b/packages/vrender/CHANGELOG.json index 327fd8b39..ff742cd06 100644 --- a/packages/vrender/CHANGELOG.json +++ b/packages/vrender/CHANGELOG.json @@ -1,6 +1,12 @@ { "name": "@visactor/vrender", "entries": [ + { + "version": "1.1.13", + "tag": "@visactor/vrender_v1.1.13", + "date": "Fri, 30 Oct 2026 02:30:40 GMT", + "comments": {} + }, { "version": "1.1.12", "tag": "@visactor/vrender_v1.1.12", diff --git a/packages/vrender/CHANGELOG.md b/packages/vrender/CHANGELOG.md index e66fe0ef6..bddb56153 100644 --- a/packages/vrender/CHANGELOG.md +++ b/packages/vrender/CHANGELOG.md @@ -1,6 +1,11 @@ # Change Log - @visactor/vrender -This log was last generated on Tue, 13 Oct 2026 08:17:49 GMT and should not be manually modified. +This log was last generated on Fri, 30 Oct 2026 02:30:40 GMT and should not be manually modified. + +## 1.1.13 +Fri, 30 Oct 2026 02:30:40 GMT + +_Version update only_ ## 1.1.12 Tue, 13 Oct 2026 08:17:49 GMT diff --git a/packages/vrender/package.json b/packages/vrender/package.json index dc2d9f81e..3942a73aa 100644 --- a/packages/vrender/package.json +++ b/packages/vrender/package.json @@ -1,6 +1,6 @@ { "name": "@visactor/vrender", - "version": "1.1.12", + "version": "1.1.13", "description": "", "sideEffects": true, "main": "cjs/index.js", @@ -32,10 +32,10 @@ "test-watch": "cross-env DEBUG_MODE=1 jest --watch -c jest.config.js" }, "dependencies": { - "@visactor/vrender-core": "workspace:1.1.12", - "@visactor/vrender-kits": "workspace:1.1.12", - "@visactor/vrender-animate": "workspace:1.1.12", - "@visactor/vrender-components": "workspace:1.1.12" + "@visactor/vrender-core": "workspace:1.1.13", + "@visactor/vrender-kits": "workspace:1.1.13", + "@visactor/vrender-animate": "workspace:1.1.13", + "@visactor/vrender-components": "workspace:1.1.13" }, "devDependencies": { "@internal/bundler": "workspace:*", diff --git a/tools/bugserver-trigger/package.json b/tools/bugserver-trigger/package.json index 7ae572dcb..665144251 100644 --- a/tools/bugserver-trigger/package.json +++ b/tools/bugserver-trigger/package.json @@ -8,11 +8,11 @@ "ci": "ts-node --transpileOnly --skipProject ./scripts/trigger-test.ts" }, "dependencies": { - "@visactor/vrender": "workspace:1.1.12", - "@visactor/vrender-core": "workspace:1.1.12", - "@visactor/vrender-kits": "workspace:1.1.12", - "@visactor/vrender-components": "workspace:1.1.12", - "@visactor/vrender-animate": "workspace:1.1.12" + "@visactor/vrender": "workspace:1.1.13", + "@visactor/vrender-core": "workspace:1.1.13", + "@visactor/vrender-kits": "workspace:1.1.13", + "@visactor/vrender-components": "workspace:1.1.13", + "@visactor/vrender-animate": "workspace:1.1.13" }, "devDependencies": { "@rushstack/eslint-patch": "~1.1.4",