Elementor Website Builder – more than just a page builder / trunk

Elementor Website Builder – more than just a page builder vtrunk

elementor / assets / js / packages / frontend-handlers / frontend-handlers.js

frontend-handlers.js in Elementor Website Builder – more than just a page builder trunk, at assets/js/packages/frontend-handlers/frontend-handlers.js

265 lines 8.4 KB

Raw Download Zip

1	(function() {
2
3	//#region \0rolldown/runtime.js
4	var __defProp = Object.defineProperty;
5	var __name = (target, value) => __defProp(target, "name", {
6	value,
7	configurable: true
8	});
9	var __exportAll = (all, no_symbols) => {
10	let target = {};
11	for (var name in all) {
12	__defProp(target, name, {
13	get: all[name],
14	enumerable: true
15	});
16	}
17	if (!no_symbols) {
18	__defProp(target, Symbol.toStringTag, { value: "Module" });
19	}
20	return target;
21	};
22
23	//#endregion
24
25	//#region packages/packages/core/frontend-handlers/src/handlers-registry.ts
26	var elementTypeHandlers = /* @__PURE__ */ new Map();
27	var elementSelectorHandlers = /* @__PURE__ */ new Map();
28	var register = ({ elementType, id, callback }) => {
29	if (!elementTypeHandlers.has(elementType)) elementTypeHandlers.set(elementType, /* @__PURE__ */ new Map());
30	if (!elementTypeHandlers.get(elementType)?.has(id)) elementTypeHandlers.get(elementType)?.set(id, callback);
31	};
32	Object.defineProperty(window, "registerElementorElement", {
33	value: register,
34	enumerable: true
35	});
36	var unregister = ({ elementType, id }) => {
37	if (!elementTypeHandlers.has(elementType)) return;
38	if (id) {
39	elementTypeHandlers.get(elementType)?.delete(id);
40	if (elementTypeHandlers.get(elementType)?.size === 0) elementTypeHandlers.delete(elementType);
41	} else elementTypeHandlers.delete(elementType);
42	};
43	var registerBySelector = ({ id, selector, callback }) => {
44	if (!elementSelectorHandlers.has(selector)) elementSelectorHandlers.set(selector, /* @__PURE__ */ new Map());
45	if (!elementSelectorHandlers.get(selector)?.has(id)) elementSelectorHandlers.get(selector)?.set(id, callback);
46	};
47	var unregisterBySelector = ({ selector, id }) => {
48	if (!elementSelectorHandlers.has(selector)) return;
49	if (id) {
50	elementSelectorHandlers.get(selector)?.delete(id);
51	if (elementSelectorHandlers.get(selector)?.size === 0) elementSelectorHandlers.delete(selector);
52	} else elementSelectorHandlers.delete(selector);
53	};
54
55	//#endregion
56	//#region packages/packages/core/frontend-handlers/src/lifecycle-events.ts
57	var unmountCallbacks = /* @__PURE__ */ new WeakMap();
58	var ELEMENT_RENDERED_EVENT_NAME = "elementor/element/rendered";
59	var ELEMENT_DESTROYED_EVENT_NAME = "elementor/element/destroyed";
60	var dispatchDestroyedEvent = (params) => {
61	params.element.dispatchEvent(new CustomEvent(ELEMENT_DESTROYED_EVENT_NAME, {
62	bubbles: true,
63	detail: params
64	}));
65	};
66	var onElementRender = ({ element, elementType, elementId }) => {
67	cleanupOnUnmount(element);
68	const controller = new AbortController();
69	const manualUnmount = [];
70	const dispatchRenderedEvent = () => {
71	onElementSelectorRender({
72	element,
73	controller
74	});
75	element.dispatchEvent(new CustomEvent(ELEMENT_RENDERED_EVENT_NAME, {
76	bubbles: true,
77	detail: {
78	element,
79	elementType,
80	elementId
81	}
82	}));
83	};
84	if (!element.isConnected) requestAnimationFrame(() => {
85	dispatchRenderedEvent();
86	});
87	else dispatchRenderedEvent();
88	if (!elementTypeHandlers.has(elementType)) return;
89	setUnmountEntry({
90	element,
91	controller,
92	manualUnmount
93	});
94	Array.from(elementTypeHandlers.get(elementType)?.values() ?? []).forEach((handler) => {
95	const settings = element.getAttribute("data-e-settings");
96	const listenToChildren = (elementTypes) => ({ render: (callback) => {
97	const listener = (event) => {
98	const { elementType: childType } = event.detail;
99	if (!elementTypes.includes(childType)) return;
100	callback(event);
101	};
102	element.addEventListener(ELEMENT_RENDERED_EVENT_NAME, listener, { signal: controller.signal });
103	element.addEventListener(ELEMENT_DESTROYED_EVENT_NAME, listener, { signal: controller.signal });
104	} });
105	const unmount = handler({
106	element,
107	signal: controller.signal,
108	settings: settings ? JSON.parse(settings) : {},
109	listenToChildren
110	});
111	if (typeof unmount === "function") manualUnmount.push(unmount);
112	});
113	};
114	var onElementSelectorRender = ({ element, controller }) => {
115	let requiresCleanup = false;
116	const manualUnmount = [];
117	Array.from(elementSelectorHandlers.entries() ?? []).forEach(([selector, handlers]) => {
118	if (!element.matches(selector)) return;
119	requiresCleanup = true;
120	Array.from(handlers.values() ?? []).forEach((handler) => {
121	const settings = element.getAttribute("data-e-settings");
122	const unmount = handler({
123	element,
124	signal: controller.signal,
125	settings: settings ? JSON.parse(settings) : {}
126	});
127	if (typeof unmount === "function") manualUnmount.push(unmount);
128	});
129	});
130	if (requiresCleanup) setUnmountEntry({
131	element,
132	controller,
133	manualUnmount
134	});
135	};
136	var onElementDestroy = ({ elementType, elementId, element }) => {
137	if (!element) return;
138	cleanupOnUnmount(element);
139	dispatchDestroyedEvent({
140	element,
141	elementType,
142	elementId
143	});
144	};
145	var setUnmountEntry = ({ element, controller, manualUnmount }) => {
146	const existingEntry = unmountCallbacks.get(element);
147	if (existingEntry) existingEntry.manualUnmount.push(...manualUnmount);
148	else unmountCallbacks.set(element, {
149	controller,
150	manualUnmount
151	});
152	};
153	var cleanupOnUnmount = (element) => {
154	const entry = unmountCallbacks.get(element);
155	if (entry) {
156	entry.controller.abort();
157	entry.manualUnmount.forEach((callback) => callback());
158	unmountCallbacks.delete(element);
159	}
160	};
161
162	//#endregion
163	//#region packages/packages/core/frontend-handlers/src/init.ts
164	var ATOMIC_SELECTOR = "[data-e-type]";
165	var domMutationObserverStarted = false;
166	var pendingMutationNodes = /* @__PURE__ */ new Set();
167	var pendingMutationsRafId = 0;
168	function init() {
169	window.addEventListener("elementor/element/render", (_event) => {
170	const { id, type, element } = _event.detail;
171	onElementRender({
172	element,
173	elementType: type,
174	elementId: id
175	});
176	});
177	window.addEventListener("elementor/element/destroy", (_event) => {
178	const { id, type, element } = _event.detail;
179	onElementDestroy({
180	elementType: type,
181	elementId: id,
182	element
183	});
184	});
185	const bootDomHandlers = () => {
186	scanDocumentForAtomicElements();
187	startObservingDomForNewAtomicElements();
188	};
189	document.addEventListener("DOMContentLoaded", bootDomHandlers);
190	if ("loading" !== document.readyState) bootDomHandlers();
191	}
192	function triggerAtomicRender(atom) {
193	const eType = atom.dataset.eType;
194	const id = atom.dataset.id;
195	if (!eType \|\| !id) return;
196	onElementRender({
197	element: atom,
198	elementType: eType,
199	elementId: id
200	});
201	}
202	function collectAtomicElementsInSubtree(root) {
203	const found = [];
204	if (root.matches(ATOMIC_SELECTOR)) found.push(root);
205	root.querySelectorAll(ATOMIC_SELECTOR).forEach((el) => {
206	found.push(el);
207	});
208	return found;
209	}
210	function scanDocumentForAtomicElements() {
211	document.querySelectorAll(ATOMIC_SELECTOR).forEach((el) => {
212	const atom = el;
213	const { eType, id } = atom.dataset;
214	if (!eType \|\| !id) return;
215	triggerAtomicRender(atom);
216	});
217	}
218	function startObservingDomForNewAtomicElements() {
219	if (domMutationObserverStarted \|\| "undefined" === typeof MutationObserver) return;
220	domMutationObserverStarted = true;
221	new MutationObserver((mutations) => {
222	for (const mutation of mutations) mutation.addedNodes.forEach((node) => {
223	pendingMutationNodes.add(node);
224	});
225	queueProcessPendingMutationNodes();
226	}).observe(document.documentElement, {
227	childList: true,
228	subtree: true
229	});
230	}
231	function queueProcessPendingMutationNodes() {
232	if (pendingMutationsRafId \|\| !pendingMutationNodes.size) return;
233	pendingMutationsRafId = requestAnimationFrame(() => {
234	pendingMutationsRafId = 0;
235	const roots = Array.from(pendingMutationNodes);
236	pendingMutationNodes.clear();
237	const atoms = /* @__PURE__ */ new Set();
238	for (const node of roots) {
239	if (Node.ELEMENT_NODE !== node.nodeType) continue;
240	collectAtomicElementsInSubtree(node).forEach((atom) => {
241	atoms.add(atom);
242	});
243	}
244	atoms.forEach((atom) => triggerAtomicRender(atom));
245	});
246	}
247
248	//#endregion
249	//#region packages/packages/core/frontend-handlers/src/index.ts
250	var src_exports = /* @__PURE__ */ __exportAll({
251	init: () => init,
252	register: () => register,
253	registerBySelector: () => registerBySelector,
254	unregister: () => unregister,
255	unregisterBySelector: () => unregisterBySelector
256	});
257
258	//#endregion
259	//#region \0elementor-package-library-entry
260	(window.elementorV2 = window.elementorV2 \|\| {}).frontendHandlers = src_exports;
261
262	//#endregion
263	})();
264	window.elementorV2.frontendHandlers?.init?.();
265	//# sourceMappingURL=frontend-handlers.js.map