15457588145

Committed 05 Jun 2025 03:16AM UTC coverage: 50.387%. First build

Build # 15457588145

Build Type

Pull #220

github

Committed by

daybrush

Commit Message

test: workflow 추가

Pull Request Pull Request #220: fix: fix offset zero direction

Run Details

344 of 887 branches covered (38.78%)

Branch coverage included in aggregate %.

8 of 10 new or added lines in 1 file covered. (80.0%)

894 of 1570 relevant lines covered (56.94%)

3.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.52

/packages/axes/src/eventInput/EventInput.ts

/*
 * Copyright (c) 2015 NAVER Corp.
 * egjs projects are licensed under the MIT license
 */
import { ExtendedEvent, InputEventType, LatestInterval } from "../types";
import { getAngle } from "../utils";
import { window } from "../browser";
import {
  ALT,
  ANY,
  CTRL,
  META,
  MOUSE_LEFT,
  MOUSE_MIDDLE,
  MOUSE_RIGHT,
  NONE,
  SHIFT,
  VELOCITY_INTERVAL,
} from "../const";

export const SUPPORT_TOUCH = "ontouchstart" in window;
export const SUPPORT_POINTER = "PointerEvent" in window;
export const SUPPORT_MSPOINTER = "MSPointerEvent" in window;
export const SUPPORT_POINTER_EVENTS = SUPPORT_POINTER || SUPPORT_MSPOINTER;

export const isValidKey = (
  event: InputEventType | WheelEvent,
  inputKey?: string[]
): boolean => {
  if (
    !inputKey ||
    inputKey.indexOf(ANY) > -1 ||
    (inputKey.indexOf(NONE) > -1 &&
      !event.shiftKey &&
      !event.ctrlKey &&
      !event.altKey &&
      !event.metaKey) ||
    (inputKey.indexOf(SHIFT) > -1 && event.shiftKey) ||
    (inputKey.indexOf(CTRL) > -1 && event.ctrlKey) ||
    (inputKey.indexOf(ALT) > -1 && event.altKey) ||
    (inputKey.indexOf(META) > -1 && event.metaKey)
  ) {
    return true;
  }
  return false;
};

export abstract class EventInput {
  public prevEvent: ExtendedEvent;
  private _latestInterval: LatestInterval;

  public abstract onEventStart(
    event: InputEventType,
    inputButton?: string[]
  ): ExtendedEvent;

  public abstract onEventMove(
    event: InputEventType,
    inputButton?: string[]
  ): ExtendedEvent;

  public abstract onEventEnd(event: InputEventType): void;

  public abstract onRelease(event: InputEventType): void;

  public abstract getTouches(
    event: InputEventType,
    inputKey?: string[],
    inputButton?: string[]
  ): number;

  protected abstract _getScale(event: InputEventType): number;

  protected abstract _getCenter(event: InputEventType): {
    x: number;
    y: number;
  };

  protected abstract _getMovement(event: InputEventType): {
    x: number;
    y: number;
  };

  public extendEvent(event: InputEventType): ExtendedEvent {
    const prevEvent = this.prevEvent;
    const center = this._getCenter(event);
    const movement = prevEvent ? this._getMovement(event) : { x: 0, y: 0 };
    const scale = prevEvent ? this._getScale(event) : 1;
    const angle = prevEvent
      ? getAngle(center.x - prevEvent.center.x, center.y - prevEvent.center.y)
      : 0;
    const deltaX = prevEvent ? prevEvent.deltaX + movement.x : movement.x;
    const deltaY = prevEvent ? prevEvent.deltaY + movement.y : movement.y;
    const offsetX = movement.x;
    const offsetY = movement.y;
    const latestInterval = this._latestInterval;
    const timeStamp = Date.now();
    const deltaTime = latestInterval ? timeStamp - latestInterval.timestamp : 0;
    let velocityX = prevEvent ? prevEvent.velocityX : 0;
    let velocityY = prevEvent ? prevEvent.velocityY : 0;
    let directionX = prevEvent ? prevEvent.directionX : 1;
    let directionY = prevEvent ? prevEvent.directionY : 1;


    // If offset is 0, it inherits the direction of the previous event.
    if (offsetX > 0) {
      directionX = 1;
    } else if (offsetX < 0) {
      directionX = -1;
    }
    if (offsetY > 0) {
      directionY = 1;
    } else if (offsetY < 0) {
      directionY = -1;
    }
    if (!latestInterval || deltaTime >= VELOCITY_INTERVAL) {
      if (latestInterval) {
        [velocityX, velocityY] = [
          (deltaX - latestInterval.deltaX) / deltaTime,
          (deltaY - latestInterval.deltaY) / deltaTime,
        ];
      }
      this._latestInterval = {
        timestamp: timeStamp,
        deltaX,
        deltaY,
      };
    }
    return {
      srcEvent: event,
      scale,
      angle,
      center,
      deltaX,
      deltaY,
      offsetX,
      offsetY,
      directionX,
      directionY,
      velocityX,
      velocityY,
      preventSystemEvent: true,
    };
  }

  protected _getDistance(
    start: Touch | PointerEvent,
    end: Touch | PointerEvent
  ): number {
    const x = end.clientX - start.clientX;
    const y = end.clientY - start.clientY;
    return Math.sqrt(x * x + y * y);
  }

  protected _getButton(event: InputEventType): string {
    const buttonCodeMap = { 1: MOUSE_LEFT, 2: MOUSE_RIGHT, 4: MOUSE_MIDDLE };
    const button = this._isTouchEvent(event)
      ? MOUSE_LEFT
      : buttonCodeMap[event.buttons];
    return button ? button : null;
  }

  protected _isTouchEvent(event: InputEventType): event is TouchEvent {
    return event.type && event.type.indexOf("touch") > -1;
  }

  protected _isValidButton(button: string, inputButton: string[]): boolean {
    return inputButton.indexOf(button) > -1;
  }

  protected _isValidEvent(
    event: InputEventType,
    inputKey?: string[],
    inputButton?: string[]
  ): boolean {
    return (
      (!inputKey || isValidKey(event, inputKey)) &&
      (!inputButton || this._isValidButton(this._getButton(event), inputButton))
    );
  }

  protected _preventMouseButton(event: InputEventType, button: string): void {
    if (button === MOUSE_RIGHT) {
      window.addEventListener("contextmenu", this._stopContextMenu);
    } else if (button === MOUSE_MIDDLE) {
      event.preventDefault();
    }
  }

  private _stopContextMenu = (event: InputEventType) => {
    event.preventDefault();
    window.removeEventListener("contextmenu", this._stopContextMenu);
  };
}

1	/*
2	* Copyright (c) 2015 NAVER Corp.
3	* egjs projects are licensed under the MIT license
4	*/
5	import { ExtendedEvent, InputEventType, LatestInterval } from "../types";
6	import { getAngle } from "../utils";	9✔
7	import { window } from "../browser";	9✔
8	import {	9✔
9	ALT,
10	ANY,
11	CTRL,
12	META,
13	MOUSE_LEFT,
14	MOUSE_MIDDLE,
15	MOUSE_RIGHT,
16	NONE,
17	SHIFT,
18	VELOCITY_INTERVAL,
19	} from "../const";
20
21	export const SUPPORT_TOUCH = "ontouchstart" in window;	9✔
22	export const SUPPORT_POINTER = "PointerEvent" in window;	9✔
23	export const SUPPORT_MSPOINTER = "MSPointerEvent" in window;	9✔
24	export const SUPPORT_POINTER_EVENTS = SUPPORT_POINTER \|\| SUPPORT_MSPOINTER;	9!
25
26	export const isValidKey = (	9✔
27	event: InputEventType \| WheelEvent,
28	inputKey?: string[]
29	): boolean => {
30	if (	4!
31	!inputKey \|\|	8!
32	inputKey.indexOf(ANY) > -1 \|\|
33	(inputKey.indexOf(NONE) > -1 &&
34	!event.shiftKey &&
35	!event.ctrlKey &&
36	!event.altKey &&
37	!event.metaKey) \|\|
38	(inputKey.indexOf(SHIFT) > -1 && event.shiftKey) \|\|
39	(inputKey.indexOf(CTRL) > -1 && event.ctrlKey) \|\|
40	(inputKey.indexOf(ALT) > -1 && event.altKey) \|\|
41	(inputKey.indexOf(META) > -1 && event.metaKey)
42	) {
43	return true;	4✔
44	}
45	return false;	×
46	};
47
48	export abstract class EventInput {	10✔
49	public prevEvent: ExtendedEvent;
50	private _latestInterval: LatestInterval;
51
52	public abstract onEventStart(
53	event: InputEventType,
54	inputButton?: string[]
55	): ExtendedEvent;
56
57	public abstract onEventMove(
58	event: InputEventType,
59	inputButton?: string[]
60	): ExtendedEvent;
61
62	public abstract onEventEnd(event: InputEventType): void;
63
64	public abstract onRelease(event: InputEventType): void;
65
66	public abstract getTouches(
67	event: InputEventType,
68	inputKey?: string[],
69	inputButton?: string[]
70	): number;
71
72	protected abstract _getScale(event: InputEventType): number;
73
74	protected abstract _getCenter(event: InputEventType): {
75	x: number;
76	y: number;
77	};
78
79	protected abstract _getMovement(event: InputEventType): {
80	x: number;
81	y: number;
82	};
83
84	public extendEvent(event: InputEventType): ExtendedEvent {	9✔
85	const prevEvent = this.prevEvent;	4✔
86	const center = this._getCenter(event);	4✔
87	const movement = prevEvent ? this._getMovement(event) : { x: 0, y: 0 };	4✔
88	const scale = prevEvent ? this._getScale(event) : 1;	4✔
89	const angle = prevEvent	4✔
90	? getAngle(center.x - prevEvent.center.x, center.y - prevEvent.center.y)	4✔
91	: 0;
92	const deltaX = prevEvent ? prevEvent.deltaX + movement.x : movement.x;	4✔
93	const deltaY = prevEvent ? prevEvent.deltaY + movement.y : movement.y;	4✔
94	const offsetX = movement.x;	4✔
95	const offsetY = movement.y;	4✔
96	const latestInterval = this._latestInterval;	4✔
97	const timeStamp = Date.now();	4✔
98	const deltaTime = latestInterval ? timeStamp - latestInterval.timestamp : 0;	4✔
99	let velocityX = prevEvent ? prevEvent.velocityX : 0;	4✔
100	let velocityY = prevEvent ? prevEvent.velocityY : 0;	4✔
101	let directionX = prevEvent ? prevEvent.directionX : 1;	4✔
102	let directionY = prevEvent ? prevEvent.directionY : 1;	4✔
103
104
105	// If offset is 0, it inherits the direction of the previous event.
106	if (offsetX > 0) {	4!
NEW 107	directionX = 1;	×
108	} else if (offsetX < 0) {	4✔
109	directionX = -1;	2✔
110	}
111	if (offsetY > 0) {	4!
NEW 112	directionY = 1;	×
113	} else if (offsetY < 0) {	4✔
114	directionY = -1;	2✔
115	}
116	if (!latestInterval \|\| deltaTime >= VELOCITY_INTERVAL) {	4✔
117	if (latestInterval) {	3✔
118	[velocityX, velocityY] = [	2✔
119	(deltaX - latestInterval.deltaX) / deltaTime,
120	(deltaY - latestInterval.deltaY) / deltaTime,
121	];
122	}
123	this._latestInterval = {	3✔
124	timestamp: timeStamp,
125	deltaX,
126	deltaY,
127	};
128	}
129	return {	4✔
130	srcEvent: event,
131	scale,
132	angle,
133	center,
134	deltaX,
135	deltaY,
136	offsetX,
137	offsetY,
138	directionX,
139	directionY,
140	velocityX,
141	velocityY,
142	preventSystemEvent: true,
143	};
144	}
145
146	protected _getDistance(	9✔
147	start: Touch \| PointerEvent,
148	end: Touch \| PointerEvent
149	): number {
150	const x = end.clientX - start.clientX;	×
151	const y = end.clientY - start.clientY;	×
152	return Math.sqrt(x * x + y * y);	×
153	}
154
155	protected _getButton(event: InputEventType): string {	9✔
156	const buttonCodeMap = { 1: MOUSE_LEFT, 2: MOUSE_RIGHT, 4: MOUSE_MIDDLE };	5✔
157	const button = this._isTouchEvent(event)	5✔
158	? MOUSE_LEFT	5!
159	: buttonCodeMap[event.buttons];
160	return button ? button : null;	5!
161	}
162
163	protected _isTouchEvent(event: InputEventType): event is TouchEvent {	9✔
164	return event.type && event.type.indexOf("touch") > -1;	25✔
165	}
166
167	protected _isValidButton(button: string, inputButton: string[]): boolean {	9✔
168	return inputButton.indexOf(button) > -1;	4✔
169	}
170
171	protected _isValidEvent(	9✔
172	event: InputEventType,
173	inputKey?: string[],
174	inputButton?: string[]
175	): boolean {
176	return (	4✔
177	(!inputKey \|\| isValidKey(event, inputKey)) &&	16✔
178	(!inputButton \|\| this._isValidButton(this._getButton(event), inputButton))
179	);
180	}
181
182	protected _preventMouseButton(event: InputEventType, button: string): void {	9✔
183	if (button === MOUSE_RIGHT) {	1!
184	window.addEventListener("contextmenu", this._stopContextMenu);	×
185	} else if (button === MOUSE_MIDDLE) {	1!
186	event.preventDefault();	×
187	}
188	}
189
190	private _stopContextMenu = (event: InputEventType) => {	1✔
191	event.preventDefault();	×
192	window.removeEventListener("contextmenu", this._stopContextMenu);	×
193	};
194	}	9✔

naver / egjs-axes / 15457588145

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous