Elementor Website Builder – more than just a page builder / 3.13.0-beta1

Elementor Website Builder – more than just a page builder v3.13.0-beta1

elementor / assets / js / packages / v1-adapters.js

v1-adapters.js in Elementor Website Builder – more than just a page builder 3.13.0-beta1, at assets/js/packages/v1-adapters.js

355 lines 11.0 KB

Raw Download Zip

1	/******/ (function() { // webpackBootstrap
2	/******/ "use strict";
3	/******/ // The require scope
4	/******/ var __webpack_require__ = {};
5	/******/
6	/************************************************************************/
7	/*****/ / webpack/runtime/define property getters */
8	/******/ !function() {
9	/******/ // define getter functions for harmony exports
10	/******/ __webpack_require__.d = function(exports, definition) {
11	/******/ for(var key in definition) {
12	/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
13	/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
14	/******/ }
15	/******/ }
16	/******/ };
17	/******/ }();
18	/******/
19	/*****/ / webpack/runtime/hasOwnProperty shorthand */
20	/******/ !function() {
21	/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
22	/******/ }();
23	/******/
24	/*****/ / webpack/runtime/make namespace object */
25	/******/ !function() {
26	/******/ // define __esModule on exports
27	/******/ __webpack_require__.r = function(exports) {
28	/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
29	/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
30	/******/ }
31	/******/ Object.defineProperty(exports, '__esModule', { value: true });
32	/******/ };
33	/******/ }();
34	/******/
35	/************************************************************************/
36	var __webpack_exports__ = {};
37	// ESM COMPAT FLAG
38	__webpack_require__.r(__webpack_exports__);
39
40	// EXPORTS
41	__webpack_require__.d(__webpack_exports__, {
42	"commandEndEvent": function() { return /* reexport */ commandEndEvent; },
43	"commandStartEvent": function() { return /* reexport */ commandStartEvent; },
44	"dispatchReadyEvent": function() { return /* reexport */ dispatchReadyEvent; },
45	"editModeChangeEvent": function() { return /* reexport */ editModeChangeEvent; },
46	"flushListeners": function() { return /* reexport */ flushListeners; },
47	"getCurrentEditMode": function() { return /* reexport */ getCurrentEditMode; },
48	"isReady": function() { return /* reexport */ isReady; },
49	"isRouteActive": function() { return /* reexport */ isRouteActive; },
50	"listenTo": function() { return /* reexport */ listenTo; },
51	"openRoute": function() { return /* reexport */ openRoute; },
52	"routeCloseEvent": function() { return /* reexport */ routeCloseEvent; },
53	"routeOpenEvent": function() { return /* reexport */ routeOpenEvent; },
54	"runCommand": function() { return /* reexport */ runCommand; },
55	"setReady": function() { return /* reexport */ setReady; },
56	"useIsPreviewMode": function() { return /* reexport */ useIsPreviewMode; },
57	"useIsRouteActive": function() { return /* reexport */ useIsRouteActive; },
58	"useListenTo": function() { return /* reexport */ useListenTo; },
59	"useRouteStatus": function() { return /* reexport */ useRouteStatus; },
60	"v1ReadyEvent": function() { return /* reexport */ v1ReadyEvent; },
61	"windowEvent": function() { return /* reexport */ windowEvent; }
62	});
63
64	;// CONCATENATED MODULE: ./packages/v1-adapters/src/dispatchers/utils.ts
65	function isJQueryDeferred(value) {
66	// TODO: Copied from:
67	// https://github.com/elementor/elementor/blob/6a74fc9/modules/web-cli/assets/js/core/commands.js#L410
68
69	return !!value && 'object' === typeof value && Object.hasOwn(value, 'promise') && Object.hasOwn(value, 'then') && Object.hasOwn(value, 'fail');
70	}
71	function promisifyJQueryDeferred(deferred) {
72	return new Promise((resolve, reject) => {
73	deferred.then(resolve, reject);
74	});
75	}
76	;// CONCATENATED MODULE: ./packages/v1-adapters/src/dispatchers/dispatchers.ts
77
78	function runCommand(command, args) {
79	const extendedWindow = window;
80	if (!extendedWindow.$e?.run) {
81	return Promise.reject('`$e.run()` is not available');
82	}
83	const result = extendedWindow.$e.run(command, args);
84	if (result instanceof Promise) {
85	return result;
86	}
87	if (isJQueryDeferred(result)) {
88	return promisifyJQueryDeferred(result);
89	}
90	return Promise.resolve(result);
91	}
92	function openRoute(route) {
93	const extendedWindow = window;
94	if (!extendedWindow.$e?.route) {
95	return Promise.reject('`$e.route()` is not available');
96	}
97	try {
98	return Promise.resolve(extendedWindow.$e.route(route));
99	} catch (e) {
100	return Promise.reject(e);
101	}
102	}
103	;// CONCATENATED MODULE: ./packages/v1-adapters/src/dispatchers/index.ts
104
105	;// CONCATENATED MODULE: external "React"
106	var external_React_namespaceObject = React;
107	;// CONCATENATED MODULE: ./packages/v1-adapters/src/listeners/event-creators.ts
108	const commandStartEvent = command => {
109	return {
110	type: 'command',
111	name: command,
112	state: 'before'
113	};
114	};
115	const commandEndEvent = command => {
116	return {
117	type: 'command',
118	name: command,
119	state: 'after'
120	};
121	};
122	const routeOpenEvent = route => {
123	return {
124	type: 'route',
125	name: route,
126	state: 'open'
127	};
128	};
129	const routeCloseEvent = route => {
130	return {
131	type: 'route',
132	name: route,
133	state: 'close'
134	};
135	};
136	const windowEvent = event => {
137	return {
138	type: 'window-event',
139	name: event
140	};
141	};
142	const v1ReadyEvent = () => {
143	return windowEvent('elementor/initialized');
144	};
145	const editModeChangeEvent = () => {
146	return windowEvent('elementor/edit-mode/change');
147	};
148	;// CONCATENATED MODULE: ./packages/v1-adapters/src/listeners/is-ready.ts
149	/**
150	* This file is used to store the state of the isReady variable, which is used to determine
151	* if the adapter is ready to receive events (editor v1 and v2 are loaded).
152	*/
153
154	let ready = false;
155	function isReady() {
156	return ready;
157	}
158	function setReady(value) {
159	ready = value;
160	}
161	;// CONCATENATED MODULE: ./packages/v1-adapters/src/listeners/utils.ts
162
163	function dispatchReadyEvent() {
164	return getV1LoadingPromise().then(() => {
165	setReady(true);
166	window.dispatchEvent(new CustomEvent('elementor/initialized'));
167	});
168	}
169	function getV1LoadingPromise() {
170	const v1LoadingPromise = window.__elementorEditorV1LoadingPromise;
171	if (!v1LoadingPromise) {
172	return Promise.reject('Elementor Editor V1 is not loaded');
173	}
174	return v1LoadingPromise;
175	}
176	function normalizeEvent(e) {
177	if (e instanceof CustomEvent && e.detail?.command) {
178	return {
179	type: 'command',
180	command: e.detail.command,
181	args: e.detail.args,
182	originalEvent: e
183	};
184	}
185	if (e instanceof CustomEvent && e.detail?.route) {
186	return {
187	type: 'route',
188	route: e.detail.route,
189	originalEvent: e
190	};
191	}
192	return {
193	type: 'window-event',
194	event: e.type,
195	originalEvent: e
196	};
197	}
198	;// CONCATENATED MODULE: ./packages/v1-adapters/src/listeners/listeners.ts
199
200
201	const callbacksByEvent = new Map();
202	let abortController = new AbortController();
203	function listenTo(eventDescriptors, callback) {
204	if (!Array.isArray(eventDescriptors)) {
205	eventDescriptors = [eventDescriptors];
206	}
207
208	// @see https://github.com/typescript-eslint/typescript-eslint/issues/2841
209	// eslint-disable-next-line array-callback-return -- Clashes with typescript.
210	const cleanups = eventDescriptors.map(event => {
211	const {
212	type,
213	name
214	} = event;
215	switch (type) {
216	case 'command':
217	return registerCommandListener(name, event.state, callback);
218	case 'route':
219	return registerRouteListener(name, event.state, callback);
220	case 'window-event':
221	return registerWindowEventListener(name, callback);
222	}
223	});
224	return () => {
225	cleanups.forEach(cleanup => cleanup());
226	};
227	}
228	function flushListeners() {
229	abortController.abort();
230	callbacksByEvent.clear();
231	setReady(false);
232	abortController = new AbortController();
233	}
234	function registerCommandListener(command, state, callback) {
235	return registerWindowEventListener(`elementor/commands/run/${state}`, e => {
236	const shouldRunCallback = e.type === 'command' && e.command === command;
237	if (shouldRunCallback) {
238	callback(e);
239	}
240	});
241	}
242	function registerRouteListener(route, state, callback) {
243	return registerWindowEventListener(`elementor/routes/${state}`, e => {
244	const shouldRunCallback = e.type === 'route' && e.route.startsWith(route);
245	if (shouldRunCallback) {
246	callback(e);
247	}
248	});
249	}
250	function registerWindowEventListener(event, callback) {
251	const isFirstListener = !callbacksByEvent.has(event);
252	if (isFirstListener) {
253	callbacksByEvent.set(event, []);
254	addListener(event);
255	}
256	callbacksByEvent.get(event)?.push(callback);
257	return () => {
258	const callbacks = callbacksByEvent.get(event);
259	if (!callbacks?.length) {
260	return;
261	}
262	const filtered = callbacks.filter(cb => cb !== callback);
263	callbacksByEvent.set(event, filtered);
264	};
265	}
266	function addListener(event) {
267	window.addEventListener(event, makeEventHandler(event), {
268	signal: abortController.signal
269	});
270	}
271	function makeEventHandler(event) {
272	return e => {
273	if (!isReady()) {
274	return;
275	}
276	const normalizedEvent = normalizeEvent(e);
277	callbacksByEvent.get(event)?.forEach(callback => {
278	callback(normalizedEvent);
279	});
280	};
281	}
282	;// CONCATENATED MODULE: ./packages/v1-adapters/src/listeners/index.ts
283
284
285
286
287
288	;// CONCATENATED MODULE: ./packages/v1-adapters/src/hooks/use-listen-to.ts
289
290
291	function useListenTo(event, getSnapshot, deps = []) {
292	const [snapshot, setSnapshot] = (0,external_React_namespaceObject.useState)(() => getSnapshot());
293	(0,external_React_namespaceObject.useEffect)(() => {
294	const updateState = () => setSnapshot(getSnapshot());
295
296	// Ensure the state is re-calculated when the dependencies have been changed.
297	updateState();
298	const cleanup = listenTo(event, updateState);
299	return cleanup;
300	}, deps);
301	return snapshot;
302	}
303	;// CONCATENATED MODULE: ./packages/v1-adapters/src/readers/index.ts
304	function isRouteActive(route) {
305	const extendedWindow = window;
306	return !!extendedWindow.$e?.routes?.isPartOf(route);
307	}
308	function getCurrentEditMode() {
309	const extendedWindow = window;
310	return extendedWindow.elementor?.channels?.dataEditMode?.request?.('activeMode');
311	}
312	;// CONCATENATED MODULE: ./packages/v1-adapters/src/hooks/use-is-preview-mode.ts
313
314
315
316	function useIsPreviewMode() {
317	return useListenTo(editModeChangeEvent(), () => getCurrentEditMode() === 'preview');
318	}
319	;// CONCATENATED MODULE: ./packages/v1-adapters/src/hooks/use-is-route-active.ts
320
321
322
323	function useIsRouteActive(route) {
324	return useListenTo([routeOpenEvent(route), routeCloseEvent(route)], () => isRouteActive(route), [route]);
325	}
326	;// CONCATENATED MODULE: ./packages/v1-adapters/src/hooks/use-route-status.ts
327
328
329	function useRouteStatus(route, {
330	blockOnKitRoutes = true,
331	blockOnPreviewMode = true
332	} = {}) {
333	const isRouteActive = useIsRouteActive(route);
334	const isKitRouteActive = useIsRouteActive('panel/global');
335	const isPreviewMode = useIsPreviewMode();
336	const isActive = isRouteActive && !(blockOnPreviewMode && isPreviewMode);
337	const isBlocked = blockOnPreviewMode && isPreviewMode \|\| blockOnKitRoutes && isKitRouteActive;
338	return {
339	isActive,
340	isBlocked
341	};
342	}
343	;// CONCATENATED MODULE: ./packages/v1-adapters/src/hooks/index.ts
344
345
346
347
348	;// CONCATENATED MODULE: ./packages/v1-adapters/src/index.ts
349
350
351
352
353	(window.__UNSTABLE__elementorPackages = window.__UNSTABLE__elementorPackages \|\| {}).v1Adapters = __webpack_exports__;
354	/******/ })()
355	;