Elementor Website Builder – more than just a page builder / 3.17.0-dev3

Elementor Website Builder – more than just a page builder v3.17.0-dev3

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

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

390 lines 12.3 KB

Raw Download Zip

1	/******/ (function() { // webpackBootstrap
2	/******/ "use strict";
3	/******/ var __webpack_modules__ = ({
4
5	/***/ "react":
6	/!************************!\
7	!* external ["React"] *!
8	\**************************/
9	/***/ (function(module) {
10
11	module.exports = window["React"];
12
13	/***/ })
14
15	/******/ });
16	/************************************************************************/
17	/******/ // The module cache
18	/******/ var __webpack_module_cache__ = {};
19	/******/
20	/******/ // The require function
21	/******/ function __webpack_require__(moduleId) {
22	/******/ // Check if module is in cache
23	/******/ var cachedModule = __webpack_module_cache__[moduleId];
24	/******/ if (cachedModule !== undefined) {
25	/******/ return cachedModule.exports;
26	/******/ }
27	/******/ // Create a new module (and put it into the cache)
28	/******/ var module = __webpack_module_cache__[moduleId] = {
29	/******/ // no module.id needed
30	/******/ // no module.loaded needed
31	/******/ exports: {}
32	/******/ };
33	/******/
34	/******/ // Execute the module function
35	/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
36	/******/
37	/******/ // Return the exports of the module
38	/******/ return module.exports;
39	/******/ }
40	/******/
41	/************************************************************************/
42	/*****/ / webpack/runtime/define property getters */
43	/******/ !function() {
44	/******/ // define getter functions for harmony exports
45	/******/ __webpack_require__.d = function(exports, definition) {
46	/******/ for(var key in definition) {
47	/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
48	/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
49	/******/ }
50	/******/ }
51	/******/ };
52	/******/ }();
53	/******/
54	/*****/ / webpack/runtime/hasOwnProperty shorthand */
55	/******/ !function() {
56	/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
57	/******/ }();
58	/******/
59	/*****/ / webpack/runtime/make namespace object */
60	/******/ !function() {
61	/******/ // define __esModule on exports
62	/******/ __webpack_require__.r = function(exports) {
63	/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
64	/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
65	/******/ }
66	/******/ Object.defineProperty(exports, '__esModule', { value: true });
67	/******/ };
68	/******/ }();
69	/******/
70	/************************************************************************/
71	var __webpack_exports__ = {};
72	// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
73	!function() {
74	/!*****************************************************************!\
75	!* ./node_modules/@elementor/editor-v1-adapters/dist/index.mjs *!
76	\*******************************************************************/
77	__webpack_require__.r(__webpack_exports__);
78	/* harmony export */ __webpack_require__.d(__webpack_exports__, {
79	/* harmony export / __privateDispatchReadyEvent: function() { return / binding */ dispatchReadyEvent; },
80	/* harmony export / __privateFlushListeners: function() { return / binding */ flushListeners; },
81	/* harmony export / __privateGetCurrentEditMode: function() { return / binding */ getCurrentEditMode; },
82	/* harmony export / __privateIsRouteActive: function() { return / binding */ isRouteActive; },
83	/* harmony export / __privateListenTo: function() { return / binding */ listenTo; },
84	/* harmony export / __privateOpenRoute: function() { return / binding */ openRoute; },
85	/* harmony export / __privateRegisterRoute: function() { return / binding */ registerRoute; },
86	/* harmony export / __privateRunCommand: function() { return / binding */ runCommand; },
87	/* harmony export / __privateSetReady: function() { return / binding */ setReady; },
88	/* harmony export / __privateUseIsPreviewMode: function() { return / binding */ useIsPreviewMode; },
89	/* harmony export / __privateUseIsRouteActive: function() { return / binding */ useIsRouteActive; },
90	/* harmony export / __privateUseListenTo: function() { return / binding */ useListenTo; },
91	/* harmony export / __privateUseRouteStatus: function() { return / binding */ useRouteStatus; },
92	/* harmony export / commandEndEvent: function() { return / binding */ commandEndEvent; },
93	/* harmony export / commandStartEvent: function() { return / binding */ commandStartEvent; },
94	/* harmony export / editModeChangeEvent: function() { return / binding */ editModeChangeEvent; },
95	/* harmony export / routeCloseEvent: function() { return / binding */ routeCloseEvent; },
96	/* harmony export / routeOpenEvent: function() { return / binding */ routeOpenEvent; },
97	/* harmony export / v1ReadyEvent: function() { return / binding */ v1ReadyEvent; },
98	/* harmony export / windowEvent: function() { return / binding */ windowEvent; }
99	/* harmony export */ });
100	/* harmony import / var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/! react */ "react");
101	// src/dispatchers/utils.ts
102	function isJQueryDeferred(value) {
103	return !!value && "object" === typeof value && Object.hasOwn(value, "promise") && Object.hasOwn(value, "then") && Object.hasOwn(value, "fail");
104	}
105	function promisifyJQueryDeferred(deferred) {
106	return new Promise((resolve, reject) => {
107	deferred.then(resolve, reject);
108	});
109	}
110
111	// src/dispatchers/dispatchers.ts
112	function runCommand(command, args) {
113	const extendedWindow = window;
114	if (!extendedWindow.$e?.run) {
115	return Promise.reject("`$e.run()` is not available");
116	}
117	const result = extendedWindow.$e.run(command, args);
118	if (result instanceof Promise) {
119	return result;
120	}
121	if (isJQueryDeferred(result)) {
122	return promisifyJQueryDeferred(result);
123	}
124	return Promise.resolve(result);
125	}
126	function openRoute(route) {
127	const extendedWindow = window;
128	if (!extendedWindow.$e?.route) {
129	return Promise.reject("`$e.route()` is not available");
130	}
131	try {
132	return Promise.resolve(
133	extendedWindow.$e.route(route)
134	);
135	} catch (e) {
136	return Promise.reject(e);
137	}
138	}
139	function registerRoute(route) {
140	const extendedWindow = window;
141	if (!extendedWindow.$e?.routes?.register) {
142	return Promise.reject("`$e.routes.register()` is not available");
143	}
144	const routeParts = route.split("/");
145	if (routeParts.length < 2) {
146	return Promise.reject(`\`${route}\` is an invalid route`);
147	}
148	const componentRoute = routeParts.pop();
149	const component = routeParts.join("/");
150	try {
151	return Promise.resolve(
152	extendedWindow.$e.routes.register(component, componentRoute, () => null)
153	);
154	} catch (e) {
155	return Promise.reject(e);
156	}
157	}
158
159	// src/hooks/use-listen-to.ts
160
161
162	// src/listeners/event-creators.ts
163	var commandStartEvent = (command) => {
164	return {
165	type: "command",
166	name: command,
167	state: "before"
168	};
169	};
170	var commandEndEvent = (command) => {
171	return {
172	type: "command",
173	name: command,
174	state: "after"
175	};
176	};
177	var routeOpenEvent = (route) => {
178	return {
179	type: "route",
180	name: route,
181	state: "open"
182	};
183	};
184	var routeCloseEvent = (route) => {
185	return {
186	type: "route",
187	name: route,
188	state: "close"
189	};
190	};
191	var windowEvent = (event) => {
192	return {
193	type: "window-event",
194	name: event
195	};
196	};
197	var v1ReadyEvent = () => {
198	return windowEvent("elementor/initialized");
199	};
200	var editModeChangeEvent = () => {
201	return windowEvent("elementor/edit-mode/change");
202	};
203
204	// src/listeners/is-ready.ts
205	var ready = false;
206	function isReady() {
207	return ready;
208	}
209	function setReady(value) {
210	ready = value;
211	}
212
213	// src/listeners/utils.ts
214	function dispatchReadyEvent() {
215	return getV1LoadingPromise().then(() => {
216	setReady(true);
217	window.dispatchEvent(new CustomEvent("elementor/initialized"));
218	});
219	}
220	function getV1LoadingPromise() {
221	const v1LoadingPromise = window.__elementorEditorV1LoadingPromise;
222	if (!v1LoadingPromise) {
223	return Promise.reject("Elementor Editor V1 is not loaded");
224	}
225	return v1LoadingPromise;
226	}
227	function normalizeEvent(e) {
228	if (e instanceof CustomEvent && e.detail?.command) {
229	return {
230	type: "command",
231	command: e.detail.command,
232	args: e.detail.args,
233	originalEvent: e
234	};
235	}
236	if (e instanceof CustomEvent && e.detail?.route) {
237	return {
238	type: "route",
239	route: e.detail.route,
240	originalEvent: e
241	};
242	}
243	return {
244	type: "window-event",
245	event: e.type,
246	originalEvent: e
247	};
248	}
249
250	// src/listeners/listeners.ts
251	var callbacksByEvent = /* @__PURE__ */ new Map();
252	var abortController = new AbortController();
253	function listenTo(eventDescriptors, callback) {
254	if (!Array.isArray(eventDescriptors)) {
255	eventDescriptors = [eventDescriptors];
256	}
257	const cleanups = eventDescriptors.map((event) => {
258	const { type, name } = event;
259	switch (type) {
260	case "command":
261	return registerCommandListener(name, event.state, callback);
262	case "route":
263	return registerRouteListener(name, event.state, callback);
264	case "window-event":
265	return registerWindowEventListener(name, callback);
266	}
267	});
268	return () => {
269	cleanups.forEach((cleanup) => cleanup());
270	};
271	}
272	function flushListeners() {
273	abortController.abort();
274	callbacksByEvent.clear();
275	setReady(false);
276	abortController = new AbortController();
277	}
278	function registerCommandListener(command, state, callback) {
279	return registerWindowEventListener(`elementor/commands/run/${state}`, (e) => {
280	const shouldRunCallback = e.type === "command" && e.command === command;
281	if (shouldRunCallback) {
282	callback(e);
283	}
284	});
285	}
286	function registerRouteListener(route, state, callback) {
287	return registerWindowEventListener(`elementor/routes/${state}`, (e) => {
288	const shouldRunCallback = e.type === "route" && e.route.startsWith(route);
289	if (shouldRunCallback) {
290	callback(e);
291	}
292	});
293	}
294	function registerWindowEventListener(event, callback) {
295	const isFirstListener = !callbacksByEvent.has(event);
296	if (isFirstListener) {
297	callbacksByEvent.set(event, []);
298	addListener(event);
299	}
300	callbacksByEvent.get(event)?.push(callback);
301	return () => {
302	const callbacks = callbacksByEvent.get(event);
303	if (!callbacks?.length) {
304	return;
305	}
306	const filtered = callbacks.filter((cb) => cb !== callback);
307	callbacksByEvent.set(event, filtered);
308	};
309	}
310	function addListener(event) {
311	window.addEventListener(
312	event,
313	makeEventHandler(event),
314	{ signal: abortController.signal }
315	);
316	}
317	function makeEventHandler(event) {
318	return (e) => {
319	if (!isReady()) {
320	return;
321	}
322	const normalizedEvent = normalizeEvent(e);
323	callbacksByEvent.get(event)?.forEach((callback) => {
324	callback(normalizedEvent);
325	});
326	};
327	}
328
329	// src/hooks/use-listen-to.ts
330	function useListenTo(event, getSnapshot, deps = []) {
331	const [snapshot, setSnapshot] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(() => getSnapshot());
332	(0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
333	const updateState = () => setSnapshot(getSnapshot());
334	updateState();
335	return listenTo(event, updateState);
336	}, deps);
337	return snapshot;
338	}
339
340	// src/readers/index.ts
341	function isRouteActive(route) {
342	const extendedWindow = window;
343	return !!extendedWindow.$e?.routes?.isPartOf(route);
344	}
345	function getCurrentEditMode() {
346	const extendedWindow = window;
347	return extendedWindow.elementor?.channels?.dataEditMode?.request?.("activeMode");
348	}
349
350	// src/hooks/use-is-preview-mode.ts
351	function useIsPreviewMode() {
352	return useListenTo(
353	editModeChangeEvent(),
354	() => getCurrentEditMode() === "preview"
355	);
356	}
357
358	// src/hooks/use-is-route-active.ts
359	function useIsRouteActive(route) {
360	return useListenTo(
361	[
362	routeOpenEvent(route),
363	routeCloseEvent(route)
364	],
365	() => isRouteActive(route),
366	[route]
367	);
368	}
369
370	// src/hooks/use-route-status.ts
371	function useRouteStatus(route, {
372	blockOnKitRoutes = true,
373	blockOnPreviewMode = true
374	} = {}) {
375	const isRouteActive2 = useIsRouteActive(route);
376	const isKitRouteActive = useIsRouteActive("panel/global");
377	const isPreviewMode = useIsPreviewMode();
378	const isActive = isRouteActive2 && !(blockOnPreviewMode && isPreviewMode);
379	const isBlocked = blockOnPreviewMode && isPreviewMode \|\| blockOnKitRoutes && isKitRouteActive;
380	return {
381	isActive,
382	isBlocked
383	};
384	}
385
386	//# sourceMappingURL=index.mjs.map
387	}();
388	(window.elementorV2 = window.elementorV2 \|\| {}).editorV1Adapters = __webpack_exports__;
389	/******/ })()
390	;