How to use addEventPoolingTo method in Playwright Internal

1const EVENT_POOL_SIZE = 10;
2
3const EventInterface = {
4	type: null,
5	target: null,
6	// currentTarget is set when dispatching; no use in copying it here
7	currentTarget: function() {
8		return null;
9	},
10	eventPhase: null,
11	bubbles: null,
12	cancelable: null,
13	timeStamp: function(event) {
14		return event.timeStamp || Date.now();
15	},
16	defaultPrevented: null,
17	isTrusted: null,
18};
19
20function functionThatReturnsTrue() {
21	return true;
22}
23
24function functionThatReturnsFalse() {
25	return false;
26}
27
28function SyntheticEvent(
29	dispatchConfig,
30	targetInst,
31	nativeEvent,
32	nativeEventTarget,
33) {
34	this.dispatchConfig = dispatchConfig;
35	this._targetInst = targetInst;
36	this.nativeEvent = nativeEvent;
37
38	const Interface = this.constructor.Interface;
39
40	for (const propName in Interface) {
41		if (!Interface.hasOwnProperty(propName)) {
42			continue;
43		}
44		const normalize = Interface[propName];
45		if (normalize) {
46			this[propName] = normalize(nativeEvent);
47		} else {
48			if (propName === 'target') {
49				this.target = nativeEventTarget;
50			} else {
51				this[propName] = nativeEvent[propName];
52			}
53		}
54	}
55
56	const defaultPrevented =
57		nativeEvent.defaultPrevented != null
58			? nativeEvent.defaultPrevented
59			: nativeEvent.returnValue === false;
60
61	if (defaultPrevented) {
62		this.isDefaultPrevented = functionThatReturnsTrue;
63	} else {
64		this.isDefaultPrevented = functionThatReturnsFalse;
65	}
66	this.isPropagationStopped = functionThatReturnsFalse;
67	return this;
68}
69
70Object.assign(SyntheticEvent.prototype, {
71	preventDefault: function() {
72		this.defaultPrevented = true;
73		const event = this.nativeEvent;
74		if (!event) {
75			return;
76		}
77
78		if (event.preventDefault) {
79			event.preventDefault();
80		} else if (typeof event.returnValue !== 'unknown') {
81			event.returnValue = false;
82		}
83		this.isDefaultPrevented = functionThatReturnsTrue;
84	},
85	stopPropagation: function() {
86		const event = this.nativeEvent;
87		if (!event) {
88			return;
89		}
90
91		if (event.stopPropagation) {
92			event.stopPropagation();
93		} else if (typeof event.cancelBubble !== 'unknown') {
94			event.cancelBubble = true;
95		}
96
97		this.isPropagationStopped = functionThatReturnsTrue;
98	},
99	persist: function() {
100		this.isPersistent = functionThatReturnsTrue;
101	},
102	isPersistent: functionThatReturnsFalse,
103	destructor: function() {
104		const Interface = this.constructor.Interface;
105		for (const propName in Interface) {
106			this[propName] = null;
107		}
108		this.dispatchConfig = null;
109		this._targetInst = null;
110		this.nativeEvent = null;
111		this.isDefaultPrevented = functionThatReturnsFalse;
112		this.isPropagationStopped = functionThatReturnsFalse;
113		this._dispatchListeners = null;
114		this._dispatchInstances = null;
115	},
116});
117
118SyntheticEvent.Interface = EventInterface;
119
120SyntheticEvent.extend = function(Interface) {
121	const Super = this;
122
123	const E = function() {};
124	E.prototype = Super.prototype;
125	const prototype = new E();
126
127	function Class() {
128		return Super.apply(this, arguments);
129	}
130	Object.assign(prototype, Class.prototype);
131	Class.prototype = prototype;
132	Class.prototype.constructor = Class;
133
134	Class.Interface = Object.assign({}, Super.Interface, Interface);
135	Class.extend = Super.extend;
136	addEventPoolingTo(Class);
137
138	return Class;
139};
140
141addEventPoolingTo(SyntheticEvent);
142
143function addEventPoolingTo(EventConstructor) {
144	EventConstructor.eventPool = [];
145	EventConstructor.getPooled = getPooledEvent;
146	EventConstructor.release = releasePooledEvent;
147}
148
149function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
150	const EventConstructor = this;
151	if (EventConstructor.eventPool.length) {
152		const instance = EventConstructor.eventPool.pop();
153		EventConstructor.call(
154			instance,
155			dispatchConfig,
156			targetInst,
157			nativeEvent,
158			nativeInst,
159		);
160		return instance;
161	}
162	return new EventConstructor(
163		dispatchConfig,
164		targetInst,
165		nativeEvent,
166		nativeInst,
167	);
168}
169
170function releasePooledEvent(event) {
171	const EventConstructor = this;
172	event.destructor();
173	if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
174		EventConstructor.eventPool.push(event);
175	}
176}
177
178export default SyntheticEvent;
179

Source: SyntheticEvent.js

const EVENT_POOL_SIZE = 10;

const EventInterface = {
	type: null,
	target: null,
	// currentTarget is set when dispatching; no use in copying it here
	currentTarget: function() {
		return null;
	},
	eventPhase: null,
	bubbles: null,
	cancelable: null,
	timeStamp: function(event) {
		return event.timeStamp || Date.now();
	},
	defaultPrevented: null,
	isTrusted: null,
};

function functionThatReturnsTrue() {
	return true;
}

function functionThatReturnsFalse() {
	return false;
}

function SyntheticEvent(
	dispatchConfig,
	targetInst,
	nativeEvent,
	nativeEventTarget,
) {
	this.dispatchConfig = dispatchConfig;
	this._targetInst = targetInst;
	this.nativeEvent = nativeEvent;

	const Interface = this.constructor.Interface;

	for (const propName in Interface) {
		if (!Interface.hasOwnProperty(propName)) {
			continue;
		}
		const normalize = Interface[propName];
		if (normalize) {
			this[propName] = normalize(nativeEvent);
		} else {
			if (propName === 'target') {
				this.target = nativeEventTarget;
			} else {
				this[propName] = nativeEvent[propName];
			}
		}
	}

	const defaultPrevented =
		nativeEvent.defaultPrevented != null
			? nativeEvent.defaultPrevented
			: nativeEvent.returnValue === false;

	if (defaultPrevented) {
		this.isDefaultPrevented = functionThatReturnsTrue;
	} else {
		this.isDefaultPrevented = functionThatReturnsFalse;
	}
	this.isPropagationStopped = functionThatReturnsFalse;
	return this;
}

Object.assign(SyntheticEvent.prototype, {
	preventDefault: function() {
		this.defaultPrevented = true;
		const event = this.nativeEvent;
		if (!event) {
			return;
		}

		if (event.preventDefault) {
			event.preventDefault();
		} else if (typeof event.returnValue !== 'unknown') {
			event.returnValue = false;
		}
		this.isDefaultPrevented = functionThatReturnsTrue;
	},
	stopPropagation: function() {
		const event = this.nativeEvent;
		if (!event) {
			return;
		}

		if (event.stopPropagation) {
			event.stopPropagation();
		} else if (typeof event.cancelBubble !== 'unknown') {
			event.cancelBubble = true;
		}

		this.isPropagationStopped = functionThatReturnsTrue;
	},
	persist: function() {
		this.isPersistent = functionThatReturnsTrue;
	},
	isPersistent: functionThatReturnsFalse,
	destructor: function() {
		const Interface = this.constructor.Interface;
		for (const propName in Interface) {
			this[propName] = null;
		}
		this.dispatchConfig = null;
		this._targetInst = null;
		this.nativeEvent = null;
		this.isDefaultPrevented = functionThatReturnsFalse;
		this.isPropagationStopped = functionThatReturnsFalse;
		this._dispatchListeners = null;
		this._dispatchInstances = null;
	},
});

SyntheticEvent.Interface = EventInterface;

SyntheticEvent.extend = function(Interface) {
	const Super = this;

	const E = function() {};
	E.prototype = Super.prototype;
	const prototype = new E();

	function Class() {
		return Super.apply(this, arguments);
	}
	Object.assign(prototype, Class.prototype);
	Class.prototype = prototype;
	Class.prototype.constructor = Class;

	Class.Interface = Object.assign({}, Super.Interface, Interface);
	Class.extend = Super.extend;
	addEventPoolingTo(Class);

	return Class;
};

addEventPoolingTo(SyntheticEvent);

function addEventPoolingTo(EventConstructor) {
	EventConstructor.eventPool = [];
	EventConstructor.getPooled = getPooledEvent;
	EventConstructor.release = releasePooledEvent;
}

function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
	const EventConstructor = this;
	if (EventConstructor.eventPool.length) {
		const instance = EventConstructor.eventPool.pop();
		EventConstructor.call(
			instance,
			dispatchConfig,
			targetInst,
			nativeEvent,
			nativeInst,
		);
		return instance;
	}
	return new EventConstructor(
		dispatchConfig,
		targetInst,
		nativeEvent,
		nativeInst,
	);
}

function releasePooledEvent(event) {
	const EventConstructor = this;
	event.destructor();
	if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
		EventConstructor.eventPool.push(event);
	}
}

export default SyntheticEvent;