@visactor/vrender-core/es/common/event-transformer.js

```typescript import { xxx } from '@visactor/vrender-core'; ```

import { isNumber } from "../canvas/util";

function isIdentityMatrix(matrix) {
    return 1 === matrix.a && 0 === matrix.b && 0 === matrix.c && 1 === matrix.d && 0 === matrix.e && 0 === matrix.f;
}

function cloneTouchList(touchList) {
    return touchList && 0 !== touchList.length ? Array.from(touchList, (touch => Object.assign({}, touch))) : [];
}

function cloneTouchEvent(event) {
    var _a;
    const transformedEvent = Object.create(null !== (_a = Object.getPrototypeOf(event)) && void 0 !== _a ? _a : Object.prototype);
    return Object.defineProperties(transformedEvent, {
        type: {
            value: event.type,
            configurable: !0
        },
        touches: {
            value: cloneTouchList(event.touches),
            configurable: !0
        },
        changedTouches: {
            value: cloneTouchList(event.changedTouches),
            configurable: !0
        }
    }), transformedEvent;
}

function cloneNativeEvent(event) {
    return event instanceof TouchEvent ? cloneTouchEvent(event) : new event.constructor(event.type, event);
}

function getSafeEventProperty(event, key) {
    try {
        return event[key];
    } catch (error) {
        return;
    }
}

export function createEventTransformer(containerElement, getMatrix, getRect, transformPoint) {
    return event => {
        if (!(event instanceof MouseEvent || event instanceof TouchEvent || event instanceof PointerEvent)) return event;
        const transformMatrix = getMatrix();
        if (isIdentityMatrix(transformMatrix)) return event;
        const containerRect = getRect(), transformedEvent = cloneNativeEvent(event), target = getSafeEventProperty(event, "target"), currentTarget = getSafeEventProperty(event, "currentTarget");
        if (Object.defineProperties(transformedEvent, {
            target: {
                value: target
            },
            currentTarget: {
                value: currentTarget
            }
        }), event instanceof MouseEvent || event instanceof PointerEvent) transformPoint(event.clientX, event.clientY, transformMatrix, containerRect, transformedEvent); else if (event instanceof TouchEvent) {
            const transformedTouchEvent = transformedEvent;
            if (event.touches.length > 0) {
                const touch = transformedTouchEvent.touches[0];
                transformPoint(touch.clientX, touch.clientY, transformMatrix, containerRect, touch);
            }
            if (event.changedTouches.length > 0) {
                const touch = transformedTouchEvent.changedTouches[0];
                transformPoint(touch.clientX, touch.clientY, transformMatrix, containerRect, touch);
            }
        }
        return transformedEvent;
    };
}

export function createCanvasEventTransformer(canvasElement, getMatrix, getRect, transformPoint) {
    return createEventTransformer(canvasElement.parentElement || canvasElement, getMatrix, getRect, transformPoint);
}

export function registerWindowEventTransformer(window, container, getMatrix, getRect, transformPoint) {
    const transformer = createEventTransformer(container, getMatrix, getRect, transformPoint);
    window.setEventListenerTransformer(transformer);
}

export function registerGlobalEventTransformer(global, container, getMatrix, getRect, transformPoint) {
    const transformer = createEventTransformer(container, getMatrix, getRect, transformPoint);
    global.setEventListenerTransformer(transformer);
}

export function transformPointForCanvas(clientX, clientY, matrix, rect, transformedEvent) {
    const transformedPoint = {
        x: clientX,
        y: clientY
    };
    matrix.transformPoint(transformedPoint, transformedPoint), Object.defineProperties(transformedEvent, {
        _canvasX: {
            value: transformedPoint.x
        },
        _canvasY: {
            value: transformedPoint.y
        }
    });
}

export function mapToCanvasPointForCanvas(nativeEvent) {
    var _a;
    if (isNumber(nativeEvent._canvasX) && isNumber(nativeEvent._canvasY)) return {
        x: nativeEvent._canvasX,
        y: nativeEvent._canvasY
    };
    if (nativeEvent.changedTouches) {
        const data = null !== (_a = nativeEvent.changedTouches[0]) && void 0 !== _a ? _a : {};
        return {
            x: data._canvasX,
            y: data._canvasY
        };
    }
    return {
        x: nativeEvent._canvasX || 0,
        y: nativeEvent._canvasY || 0
    };
}
//# sourceMappingURL=event-transformer.js.map