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

Elementor Website Builder – more than just a page builder vtrunk

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 trunk, at assets/js/packages/editor-v1-adapters/editor-v1-adapters.js

443 lines 14.0 KB

Raw Download Zip

1	(function(react, _elementor_utils) {
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/libs/editor-v1-adapters/src/dispatchers/utils.ts
26	function isJQueryDeferred(value) {
27	return !!value && "object" === typeof value && Object.hasOwn(value, "promise") && Object.hasOwn(value, "then") && Object.hasOwn(value, "fail");
28	}
29	function promisifyJQueryDeferred(deferred) {
30	return new Promise((resolve, reject) => {
31	deferred.then(resolve, reject);
32	});
33	}
34
35	//#endregion
36	//#region packages/packages/libs/editor-v1-adapters/src/dispatchers/dispatchers.ts
37	async function runCommand(command, args, { internal = false } = {}) {
38	const result = runCommandSync(command, args, { internal });
39	if (result instanceof Promise) return result;
40	if (isJQueryDeferred(result)) return promisifyJQueryDeferred(result);
41	return Promise.resolve(result);
42	}
43	function runCommandSync(command, args, { internal = false } = {}) {
44	const extendedWindow = window;
45	const run = internal ? extendedWindow.$e?.internal : extendedWindow.$e?.run;
46	if (!run) throw new Error(`\`${internal ? "$e.internal" : "$e.run"}()\` is not available`);
47	return run(command, args);
48	}
49	function openRoute(route) {
50	const extendedWindow = window;
51	if (!extendedWindow.$e?.route) return Promise.reject("`$e.route()` is not available");
52	try {
53	return Promise.resolve(extendedWindow.$e.route(route));
54	} catch (e) {
55	return Promise.reject(e);
56	}
57	}
58	function registerRoute(route) {
59	const extendedWindow = window;
60	if (!extendedWindow.$e?.routes?.register) return Promise.reject("`$e.routes.register()` is not available");
61	const routeParts = route.split("/");
62	if (routeParts.length < 2) return Promise.reject(`\`${route}\` is an invalid route`);
63	const componentRoute = routeParts.pop();
64	const component = routeParts.join("/");
65	try {
66	return Promise.resolve(extendedWindow.$e.routes.register(component, componentRoute, () => null));
67	} catch (e) {
68	return Promise.reject(e);
69	}
70	}
71
72	//#endregion
73	//#region packages/packages/libs/editor-v1-adapters/src/listeners/event-creators.ts
74	var commandStartEvent = (command) => {
75	return {
76	type: "command",
77	name: command,
78	state: "before"
79	};
80	};
81	var commandEndEvent = (command) => {
82	return {
83	type: "command",
84	name: command,
85	state: "after"
86	};
87	};
88	var routeOpenEvent = (route) => {
89	return {
90	type: "route",
91	name: route,
92	state: "open"
93	};
94	};
95	var routeCloseEvent = (route) => {
96	return {
97	type: "route",
98	name: route,
99	state: "close"
100	};
101	};
102	var windowEvent = (event) => {
103	return {
104	type: "window-event",
105	name: event
106	};
107	};
108	var v1ReadyEvent = () => {
109	return windowEvent("elementor/initialized");
110	};
111
112	//#endregion
113	//#region packages/packages/libs/editor-v1-adapters/src/listeners/is-ready.ts
114	var ready = false;
115	function isReady() {
116	return ready;
117	}
118	function setReady(value) {
119	ready = value;
120	}
121
122	//#endregion
123	//#region packages/packages/libs/editor-v1-adapters/src/listeners/utils.ts
124	function dispatchReadyEvent() {
125	return getV1LoadingPromise().then(() => {
126	setReady(true);
127	window.dispatchEvent(new CustomEvent("elementor/initialized"));
128	});
129	}
130	function getV1LoadingPromise() {
131	const v1LoadingPromise = window.__elementorEditorV1LoadingPromise;
132	if (!v1LoadingPromise) return Promise.reject("Elementor Editor V1 is not loaded");
133	return v1LoadingPromise;
134	}
135	function normalizeEvent(e) {
136	if (e instanceof CustomEvent && e.detail?.command) return {
137	type: "command",
138	command: e.detail.command,
139	args: e.detail.args,
140	originalEvent: e
141	};
142	if (e instanceof CustomEvent && e.detail?.route) return {
143	type: "route",
144	route: e.detail.route,
145	originalEvent: e
146	};
147	return {
148	type: "window-event",
149	event: e.type,
150	originalEvent: e
151	};
152	}
153
154	//#endregion
155	//#region packages/packages/libs/editor-v1-adapters/src/listeners/listeners.ts
156	var callbacksByEvent = /* @__PURE__ */ new Map();
157	var abortController = new AbortController();
158	function listenTo(eventDescriptors, callback) {
159	if (!Array.isArray(eventDescriptors)) eventDescriptors = [eventDescriptors];
160	const cleanups = eventDescriptors.map((event) => {
161	const { type, name } = event;
162	switch (type) {
163	case "command": return registerCommandListener(name, event.state, callback);
164	case "route": return registerRouteListener(name, event.state, callback);
165	case "window-event": return registerWindowEventListener(name, callback);
166	}
167	});
168	return () => {
169	cleanups.forEach((cleanup) => cleanup());
170	};
171	}
172	function flushListeners() {
173	abortController.abort();
174	callbacksByEvent.clear();
175	setReady(false);
176	abortController = new AbortController();
177	}
178	function registerCommandListener(command, state, callback) {
179	return registerWindowEventListener(`elementor/commands/run/${state}`, (e) => {
180	if (e.type === "command" && e.command === command) callback(e);
181	});
182	}
183	function registerRouteListener(route, state, callback) {
184	return registerWindowEventListener(`elementor/routes/${state}`, (e) => {
185	if (e.type === "route" && e.route.startsWith(route)) callback(e);
186	});
187	}
188	var V1_READY_EVENT_NAME = "elementor/initialized";
189	function registerWindowEventListener(event, callback) {
190	if (!callbacksByEvent.has(event)) {
191	callbacksByEvent.set(event, []);
192	addListener(event);
193	}
194	callbacksByEvent.get(event)?.push(callback);
195	if (event === V1_READY_EVENT_NAME && isReady()) Promise.resolve().then(() => {
196	if (callbacksByEvent.get(event)?.includes(callback)) callback({
197	type: "window-event",
198	event,
199	originalEvent: new CustomEvent(event)
200	});
201	});
202	return () => {
203	const callbacks = callbacksByEvent.get(event);
204	if (!callbacks?.length) return;
205	const filtered = callbacks.filter((cb) => cb !== callback);
206	callbacksByEvent.set(event, filtered);
207	};
208	}
209	function addListener(event) {
210	window.addEventListener(event, makeEventHandler(event), { signal: abortController.signal });
211	}
212	function makeEventHandler(event) {
213	return (e) => {
214	if (!isReady()) return;
215	const normalizedEvent = normalizeEvent(e);
216	callbacksByEvent.get(event)?.forEach((callback) => {
217	callback(normalizedEvent);
218	});
219	};
220	}
221
222	//#endregion
223	//#region packages/packages/libs/editor-v1-adapters/src/readers/index.ts
224	var EXPERIMENTAL_FEATURES = {};
225	function isRouteActive(route) {
226	return !!window.$e?.routes?.isPartOf(route);
227	}
228	var isExperimentActive = (experiment) => {
229	return !!window.elementorCommon?.config?.experimentalFeatures?.[experiment];
230	};
231
232	//#endregion
233	//#region packages/packages/libs/editor-v1-adapters/src/hooks/use-listen-to.ts
234	function useListenTo(event, getSnapshot, deps = []) {
235	const [snapshot, setSnapshot] = (0, react.useState)(() => getSnapshot());
236	(0, react.useEffect)(() => {
237	const updateState = () => setSnapshot(getSnapshot());
238	updateState();
239	return listenTo(event, updateState);
240	}, deps);
241	return snapshot;
242	}
243
244	//#endregion
245	//#region packages/packages/libs/editor-v1-adapters/src/hooks/use-is-route-active.ts
246	function useIsRouteActive(route) {
247	return useListenTo([routeOpenEvent(route), routeCloseEvent(route)], () => isRouteActive(route), [route]);
248	}
249
250	//#endregion
251	//#region packages/packages/libs/editor-v1-adapters/src/edit-mode.ts
252	function useEditMode() {
253	return useListenTo(windowEvent("elementor/edit-mode/change"), getCurrentEditMode);
254	}
255	function getCurrentEditMode() {
256	return window.elementor.channels.dataEditMode.request("activeMode");
257	}
258	function changeEditMode(newMode) {
259	return window.elementor.changeEditMode(newMode);
260	}
261
262	//#endregion
263	//#region packages/packages/libs/editor-v1-adapters/src/hooks/use-route-status.ts
264	function useRouteStatus(route, { blockOnKitRoutes = true, allowedEditModes = ["edit"] } = {}) {
265	const isRouteActive = useIsRouteActive(route);
266	const isKitRouteActive = useIsRouteActive("panel/global");
267	const currentEditMode = useEditMode();
268	const isBlockedByEditMode = !allowedEditModes.includes(currentEditMode);
269	return {
270	isActive: isRouteActive && !isBlockedByEditMode,
271	isBlocked: isBlockedByEditMode \|\| blockOnKitRoutes && isKitRouteActive
272	};
273	}
274
275	//#endregion
276	//#region packages/packages/libs/editor-v1-adapters/src/ajax/index.ts
277	var ajax = {
278	async load(data) {
279	const extendedWindow = window;
280	return new Promise((success, error) => {
281	extendedWindow.elementorCommon?.ajax?.load({
282	...data,
283	success,
284	error
285	});
286	});
287	},
288	invalidateCache(data) {
289	window.elementorCommon?.ajax?.invalidateCache(data);
290	}
291	};
292
293	//#endregion
294	//#region packages/packages/libs/editor-v1-adapters/src/undoable/get-history-manager.ts
295	var HistoryManagerNotAvailable = (0, _elementor_utils.createError)({
296	code: "history_manager_not_available",
297	message: "Cannot access History manager."
298	});
299	function getHistoryManager() {
300	const historyManger = window.elementor?.documents?.getCurrent?.()?.history;
301	if (!historyManger) throw new HistoryManagerNotAvailable();
302	return historyManger;
303	}
304
305	//#endregion
306	//#region packages/packages/libs/editor-v1-adapters/src/undoable/undoable.ts
307	function undoable(actions, options) {
308	actions.redo ?? (actions.redo = actions.do);
309	const _addHistoryItem = options.debounce ? (0, _elementor_utils.debounce)(addHistoryItem, options.debounce.wait) : addHistoryItem;
310	return (payload) => {
311	const _payload = payload;
312	const _actions = actions;
313	let doReturn = _actions.do(_payload);
314	let undoReturn;
315	_addHistoryItem({
316	title: normalizeToGenerator(options.title)(_payload, doReturn),
317	subTitle: normalizeToGenerator(options.subtitle)(_payload, doReturn),
318	type: "",
319	restore: (_, isRedo) => {
320	if (isRedo) {
321	doReturn = _actions.redo(_payload, doReturn, undoReturn);
322	return;
323	}
324	undoReturn = _actions.undo(_payload, doReturn);
325	}
326	});
327	return doReturn;
328	};
329	}
330	function normalizeToGenerator(value) {
331	return typeof value === "function" ? value : () => value ?? "";
332	}
333	function addHistoryItem(item) {
334	getHistoryManager().addItem(item);
335	}
336
337	//#endregion
338	//#region packages/packages/libs/editor-v1-adapters/src/data-hooks/register-data-hook.ts
339	var hookId = 0;
340	function registerDataHook(type, command, callback) {
341	const hooksClasses = window.$e?.modules?.hookData;
342	const HookClass = {
343	after: hooksClasses?.After,
344	dependency: hooksClasses?.Dependency
345	}[type];
346	if (!HookClass) throw new Error(`Data hook '${type}' is not available`);
347	const currentHookId = ++hookId;
348	const hook = new class extends HookClass {
349	getCommand() {
350	return command;
351	}
352	getId() {
353	return `${command}--data--${currentHookId}`;
354	}
355	apply(args, result) {
356	const hookOptions = {};
357	const currentWindow = window;
358	const commandsCurrentTrace = currentWindow.$e?.commands?.currentTrace;
359	if (commandsCurrentTrace) hookOptions.commandsCurrentTrace = commandsCurrentTrace;
360	const currentHistoryItemId = currentWindow.elementor?.documents?.getCurrent()?.history?.getCurrentId();
361	if (currentHistoryItemId) hookOptions.currentHistoryItemId = currentHistoryItemId;
362	if (type === "dependency") return callback(args, hookOptions);
363	return callback(args, result, hookOptions);
364	}
365	}();
366	hook.register();
367	return hook;
368	}
369
370	//#endregion
371	//#region packages/packages/libs/editor-v1-adapters/src/data-hooks/block-command.ts
372	function blockCommand({ command, condition }) {
373	return registerDataHook("dependency", command, (args) => {
374	return !condition(args);
375	});
376	}
377
378	//#endregion
379	//#region packages/packages/libs/editor-v1-adapters/src/canvas/get-canvas-iframe-document.ts
380	function getCanvasIframeDocument() {
381	return window.elementor?.$preview?.[0]?.contentDocument;
382	}
383
384	//#endregion
385	//#region packages/packages/libs/editor-v1-adapters/src/config/get-elementor-globals.ts
386	var getElementorConfig = () => {
387	return window.elementor?.config ?? {};
388	};
389	var getElementorFrontendConfig = () => {
390	return window.elementorFrontend?.config ?? {};
391	};
392
393	//#endregion
394	//#region packages/packages/libs/editor-v1-adapters/src/config/enqueue-font.ts
395	var enqueueFont = (fontFamily, context = "preview") => {
396	return window.elementor?.helpers?.enqueueFont?.(fontFamily, context) ?? null;
397	};
398
399	//#endregion
400	//#region packages/packages/libs/editor-v1-adapters/src/index.ts
401	var src_exports = /* @__PURE__ */ __exportAll({
402	EXPERIMENTAL_FEATURES: () => EXPERIMENTAL_FEATURES,
403	__privateDispatchReadyEvent: () => dispatchReadyEvent,
404	__privateFlushListeners: () => flushListeners,
405	__privateIsReady: () => isReady,
406	__privateIsRouteActive: () => isRouteActive,
407	__privateListenTo: () => listenTo,
408	__privateOpenRoute: () => openRoute,
409	__privateRegisterRoute: () => registerRoute,
410	__privateRunCommand: () => runCommand,
411	__privateRunCommandSync: () => runCommandSync,
412	__privateSetReady: () => setReady,
413	__privateUseIsRouteActive: () => useIsRouteActive,
414	__privateUseListenTo: () => useListenTo,
415	__privateUseRouteStatus: () => useRouteStatus,
416	ajax: () => ajax,
417	blockCommand: () => blockCommand,
418	changeEditMode: () => changeEditMode,
419	commandEndEvent: () => commandEndEvent,
420	commandStartEvent: () => commandStartEvent,
421	enqueueFont: () => enqueueFont,
422	getCanvasIframeDocument: () => getCanvasIframeDocument,
423	getCurrentEditMode: () => getCurrentEditMode,
424	getElementorConfig: () => getElementorConfig,
425	getElementorFrontendConfig: () => getElementorFrontendConfig,
426	isExperimentActive: () => isExperimentActive,
427	registerDataHook: () => registerDataHook,
428	routeCloseEvent: () => routeCloseEvent,
429	routeOpenEvent: () => routeOpenEvent,
430	undoable: () => undoable,
431	useEditMode: () => useEditMode,
432	v1ReadyEvent: () => v1ReadyEvent,
433	windowEvent: () => windowEvent
434	});
435
436	//#endregion
437	//#region \0elementor-package-library-entry
438	(window.elementorV2 = window.elementorV2 \|\| {}).editorV1Adapters = src_exports;
439
440	//#endregion
441	})(React, elementorV2.utils);
442	window.elementorV2.editorV1Adapters?.init?.();
443	//# sourceMappingURL=editor-v1-adapters.js.map