Elementor Website Builder – more than just a page builder / 3.14.0-beta5

Elementor Website Builder – more than just a page builder v3.14.0-beta5

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

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

371 lines 11.7 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 / "commandEndEvent": function() { return / binding */ commandEndEvent; },
80	/* harmony export / "commandStartEvent": function() { return / binding */ commandStartEvent; },
81	/* harmony export / "dispatchReadyEvent": function() { return / binding */ dispatchReadyEvent; },
82	/* harmony export / "editModeChangeEvent": function() { return / binding */ editModeChangeEvent; },
83	/* harmony export / "flushListeners": function() { return / binding */ flushListeners; },
84	/* harmony export / "getCurrentEditMode": function() { return / binding */ getCurrentEditMode; },
85	/* harmony export / "isReady": function() { return / binding */ isReady; },
86	/* harmony export / "isRouteActive": function() { return / binding */ isRouteActive; },
87	/* harmony export / "listenTo": function() { return / binding */ listenTo; },
88	/* harmony export / "openRoute": function() { return / binding */ openRoute; },
89	/* harmony export / "routeCloseEvent": function() { return / binding */ routeCloseEvent; },
90	/* harmony export / "routeOpenEvent": function() { return / binding */ routeOpenEvent; },
91	/* harmony export / "runCommand": function() { return / binding */ runCommand; },
92	/* harmony export / "setReady": function() { return / binding */ setReady; },
93	/* harmony export / "useIsPreviewMode": function() { return / binding */ useIsPreviewMode; },
94	/* harmony export / "useIsRouteActive": function() { return / binding */ useIsRouteActive; },
95	/* harmony export / "useListenTo": function() { return / binding */ useListenTo; },
96	/* harmony export / "useRouteStatus": function() { return / binding */ useRouteStatus; },
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
140	// src/hooks/use-listen-to.ts
141
142
143	// src/listeners/event-creators.ts
144	var commandStartEvent = (command) => {
145	return {
146	type: "command",
147	name: command,
148	state: "before"
149	};
150	};
151	var commandEndEvent = (command) => {
152	return {
153	type: "command",
154	name: command,
155	state: "after"
156	};
157	};
158	var routeOpenEvent = (route) => {
159	return {
160	type: "route",
161	name: route,
162	state: "open"
163	};
164	};
165	var routeCloseEvent = (route) => {
166	return {
167	type: "route",
168	name: route,
169	state: "close"
170	};
171	};
172	var windowEvent = (event) => {
173	return {
174	type: "window-event",
175	name: event
176	};
177	};
178	var v1ReadyEvent = () => {
179	return windowEvent("elementor/initialized");
180	};
181	var editModeChangeEvent = () => {
182	return windowEvent("elementor/edit-mode/change");
183	};
184
185	// src/listeners/is-ready.ts
186	var ready = false;
187	function isReady() {
188	return ready;
189	}
190	function setReady(value) {
191	ready = value;
192	}
193
194	// src/listeners/utils.ts
195	function dispatchReadyEvent() {
196	return getV1LoadingPromise().then(() => {
197	setReady(true);
198	window.dispatchEvent(new CustomEvent("elementor/initialized"));
199	});
200	}
201	function getV1LoadingPromise() {
202	const v1LoadingPromise = window.__elementorEditorV1LoadingPromise;
203	if (!v1LoadingPromise) {
204	return Promise.reject("Elementor Editor V1 is not loaded");
205	}
206	return v1LoadingPromise;
207	}
208	function normalizeEvent(e) {
209	if (e instanceof CustomEvent && e.detail?.command) {
210	return {
211	type: "command",
212	command: e.detail.command,
213	args: e.detail.args,
214	originalEvent: e
215	};
216	}
217	if (e instanceof CustomEvent && e.detail?.route) {
218	return {
219	type: "route",
220	route: e.detail.route,
221	originalEvent: e
222	};
223	}
224	return {
225	type: "window-event",
226	event: e.type,
227	originalEvent: e
228	};
229	}
230
231	// src/listeners/listeners.ts
232	var callbacksByEvent = /* @__PURE__ */ new Map();
233	var abortController = new AbortController();
234	function listenTo(eventDescriptors, callback) {
235	if (!Array.isArray(eventDescriptors)) {
236	eventDescriptors = [eventDescriptors];
237	}
238	const cleanups = eventDescriptors.map((event) => {
239	const { type, name } = event;
240	switch (type) {
241	case "command":
242	return registerCommandListener(name, event.state, callback);
243	case "route":
244	return registerRouteListener(name, event.state, callback);
245	case "window-event":
246	return registerWindowEventListener(name, callback);
247	}
248	});
249	return () => {
250	cleanups.forEach((cleanup) => cleanup());
251	};
252	}
253	function flushListeners() {
254	abortController.abort();
255	callbacksByEvent.clear();
256	setReady(false);
257	abortController = new AbortController();
258	}
259	function registerCommandListener(command, state, callback) {
260	return registerWindowEventListener(`elementor/commands/run/${state}`, (e) => {
261	const shouldRunCallback = e.type === "command" && e.command === command;
262	if (shouldRunCallback) {
263	callback(e);
264	}
265	});
266	}
267	function registerRouteListener(route, state, callback) {
268	return registerWindowEventListener(`elementor/routes/${state}`, (e) => {
269	const shouldRunCallback = e.type === "route" && e.route.startsWith(route);
270	if (shouldRunCallback) {
271	callback(e);
272	}
273	});
274	}
275	function registerWindowEventListener(event, callback) {
276	const isFirstListener = !callbacksByEvent.has(event);
277	if (isFirstListener) {
278	callbacksByEvent.set(event, []);
279	addListener(event);
280	}
281	callbacksByEvent.get(event)?.push(callback);
282	return () => {
283	const callbacks = callbacksByEvent.get(event);
284	if (!callbacks?.length) {
285	return;
286	}
287	const filtered = callbacks.filter((cb) => cb !== callback);
288	callbacksByEvent.set(event, filtered);
289	};
290	}
291	function addListener(event) {
292	window.addEventListener(
293	event,
294	makeEventHandler(event),
295	{ signal: abortController.signal }
296	);
297	}
298	function makeEventHandler(event) {
299	return (e) => {
300	if (!isReady()) {
301	return;
302	}
303	const normalizedEvent = normalizeEvent(e);
304	callbacksByEvent.get(event)?.forEach((callback) => {
305	callback(normalizedEvent);
306	});
307	};
308	}
309
310	// src/hooks/use-listen-to.ts
311	function useListenTo(event, getSnapshot, deps = []) {
312	const [snapshot, setSnapshot] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(() => getSnapshot());
313	(0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
314	const updateState = () => setSnapshot(getSnapshot());
315	updateState();
316	return listenTo(event, updateState);
317	}, deps);
318	return snapshot;
319	}
320
321	// src/readers/index.ts
322	function isRouteActive(route) {
323	const extendedWindow = window;
324	return !!extendedWindow.$e?.routes?.isPartOf(route);
325	}
326	function getCurrentEditMode() {
327	const extendedWindow = window;
328	return extendedWindow.elementor?.channels?.dataEditMode?.request?.("activeMode");
329	}
330
331	// src/hooks/use-is-preview-mode.ts
332	function useIsPreviewMode() {
333	return useListenTo(
334	editModeChangeEvent(),
335	() => getCurrentEditMode() === "preview"
336	);
337	}
338
339	// src/hooks/use-is-route-active.ts
340	function useIsRouteActive(route) {
341	return useListenTo(
342	[
343	routeOpenEvent(route),
344	routeCloseEvent(route)
345	],
346	() => isRouteActive(route),
347	[route]
348	);
349	}
350
351	// src/hooks/use-route-status.ts
352	function useRouteStatus(route, {
353	blockOnKitRoutes = true,
354	blockOnPreviewMode = true
355	} = {}) {
356	const isRouteActive2 = useIsRouteActive(route);
357	const isKitRouteActive = useIsRouteActive("panel/global");
358	const isPreviewMode = useIsPreviewMode();
359	const isActive = isRouteActive2 && !(blockOnPreviewMode && isPreviewMode);
360	const isBlocked = blockOnPreviewMode && isPreviewMode \|\| blockOnKitRoutes && isKitRouteActive;
361	return {
362	isActive,
363	isBlocked
364	};
365	}
366
367	//# sourceMappingURL=index.mjs.map
368	}();
369	(window.__UNSTABLE__elementorPackages = window.__UNSTABLE__elementorPackages \|\| {}).editorV1Adapters = __webpack_exports__;
370	/******/ })()
371	;