@mx-space/cli 0.13.1 → 0.13.3

package/dist/LexicalDragon.dev-CqW7Aq5H.mjs

@@ -0,0 +1,186 @@
+import { f as namedSignals, l as effect, m as watchedSignal } from "./LexicalExtension.node-BWH6xbzG.mjs";
+import { Ar as getEditorPropertyFromDOMNode, Cr as getActiveElementDeep, W as $getSelection, Zr as isLexicalEditor, ai as safeCast, br as defineExtension, bt as $isTextNode, pt as $isRangeSelection } from "./Lexical.node-BlCLnfA6.mjs";
+//#region ../../node_modules/.pnpm/@lexical+dragon@0.46.0_typescript@6.0.3/node_modules/@lexical/dragon/dist/LexicalDragon.dev.mjs
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const TEXT_FORMAT_BY_EXEC_COMMAND = {
+	bold: "bold",
+	italic: "italic",
+	strikeThrough: "strikethrough",
+	subscript: "subscript",
+	superscript: "superscript",
+	underline: "underline"
+};
+const WINDOW_STATE_KEY = Symbol.for("@lexical/dragon/WindowState");
+function getOrCreateWindowState(targetWindow) {
+	let state = targetWindow[WINDOW_STATE_KEY];
+	if (state === void 0) {
+		state = {
+			dispose: () => {},
+			editors: /* @__PURE__ */ new Map(),
+			installs: /* @__PURE__ */ new Set()
+		};
+		targetWindow[WINDOW_STATE_KEY] = state;
+	}
+	return state;
+}
+function defaultWindow() {
+	return typeof window !== "undefined" ? window : void 0;
+}
+/**
+* Install the shared window listener that handles Dragon NaturallySpeaking's
+* web extension messages for every registered editor in the given window.
+*
+* Browsers invoke a window's message listeners in registration order, and
+* the extension's content script registers its own listener at document_end
+* of the initial page load. {@link registerDragonSupport} installs this
+* listener lazily, when an editor's root element is mounted, which loses
+* that race whenever editors mount after the initial load (a navigation in
+* a single page app, a dialog, any lazily rendered field). The extension
+* then edits the DOM directly before Lexical can stopImmediatePropagation,
+* and the edit is applied twice.
+*
+* Call this synchronously from every entrypoint that may render an editor
+* lazily, before document_end, so the listener is ahead of the extension's
+* and editors win the race no matter when they mount.
+*
+* Pass `targetWindow` to install the listener on a window other than the
+* global one (for example, an editor mounted inside an iframe). When
+* omitted, defaults to the current `window` when available. Returns a
+* teardown function; the listener for a window is removed once every
+* teardown for it (including the ones returned by
+* {@link registerDragonSupport}) has been called.
+*/
+function installDragonSupport(targetWindow = defaultWindow()) {
+	return targetWindow ? addInstall(targetWindow, Symbol("@lexical/dragon/globalInstall"), void 0) : () => {};
+}
+function addInstall(targetWindow, installKey, editor) {
+	const state = getOrCreateWindowState(targetWindow);
+	if (state.installs.size === 0) {
+		const boundHandleMessage = handleMessage.bind(targetWindow);
+		targetWindow.addEventListener("message", boundHandleMessage, true);
+		state.dispose = () => {
+			targetWindow.removeEventListener("message", boundHandleMessage, true);
+		};
+	}
+	state.installs.add(installKey);
+	if (editor) {
+		const installSet = state.editors.get(editor) || /* @__PURE__ */ new Set();
+		installSet.add(installKey);
+		state.editors.set(editor, installSet);
+	}
+	return removeInstall.bind(null, targetWindow, state, installKey, editor);
+}
+function removeInstall(targetWindow, state, installKey, editor) {
+	if (editor) {
+		const installSet = state.editors.get(editor);
+		if (installSet && installSet.delete(installKey) && installSet.size === 0) state.editors.delete(editor);
+	}
+	if (state.installs.delete(installKey) && state.installs.size === 0) {
+		state.dispose();
+		delete targetWindow[WINDOW_STATE_KEY];
+	}
+}
+function getDefaultView(el) {
+	return el && el.ownerDocument.defaultView;
+}
+function registerDragonSupport(editor) {
+	const windowSignal = watchedSignal(() => getDefaultView(editor.getRootElement()), (self) => editor.registerRootListener((rootElement) => {
+		self.value = getDefaultView(rootElement);
+	}));
+	return effect(() => {
+		const targetWindow = windowSignal.value;
+		if (targetWindow) return addInstall(targetWindow, Symbol("@lexical/dragon/editorInstall"), editor);
+	});
+}
+function getFocusedEditor(targetWindow) {
+	const state = targetWindow[WINDOW_STATE_KEY];
+	if (state === void 0) return null;
+	const activeEditor = getEditorPropertyFromDOMNode(getActiveElementDeep(targetWindow.document));
+	return isLexicalEditor(activeEditor) && state.editors.has(activeEditor) ? activeEditor : null;
+}
+function handleMessage(event) {
+	const targetWindow = this;
+	if (event.origin !== targetWindow.location.origin) return;
+	const editor = getFocusedEditor(targetWindow);
+	if (editor === null) return;
+	const data = event.data;
+	if (typeof data === "string") {
+		let parsedData;
+		try {
+			parsedData = JSON.parse(data);
+		} catch (_e) {
+			return;
+		}
+		if (parsedData && parsedData.protocol === "nuanria_messaging" && parsedData.type === "request") {
+			const payload = parsedData.payload;
+			if (payload && payload.functionId === "makeChanges") {
+				const args = payload.args;
+				if (Array.isArray(args)) {
+					const [elementStart, elementLength, text, selStart, selLength, formatCommand] = args;
+					if (![
+						elementStart,
+						elementLength,
+						selStart,
+						selLength
+					].every(Number.isFinite) || typeof text !== "string" && text !== -1) return;
+					editor.update(() => {
+						const selection = $getSelection();
+						if ($isRangeSelection(selection)) {
+							const anchor = selection.anchor;
+							let anchorNode = anchor.getNode();
+							let setSelStart = 0;
+							let setSelEnd = 0;
+							if ($isTextNode(anchorNode)) {
+								if (elementStart >= 0 && elementLength >= 0) {
+									setSelStart = elementStart;
+									setSelEnd = elementStart + elementLength;
+									selection.setTextNodeRange(anchorNode, setSelStart, anchorNode, setSelEnd);
+								}
+							}
+							if (typeof text === "string" && (setSelStart !== setSelEnd || text !== "")) {
+								selection.insertRawText(text);
+								anchorNode = anchor.getNode();
+							}
+							if ($isTextNode(anchorNode)) {
+								const anchorNodeTextLength = anchorNode.getTextContentSize();
+								setSelStart = Math.min(Math.max(selStart, 0), anchorNodeTextLength);
+								setSelEnd = selStart < 0 || selLength < 0 ? setSelStart : Math.min(selStart + selLength, anchorNodeTextLength);
+								selection.setTextNodeRange(anchorNode, setSelStart, anchorNode, setSelEnd);
+							}
+							if (typeof formatCommand === "string" && selLength > 0 && !selection.isCollapsed()) {
+								const format = TEXT_FORMAT_BY_EXEC_COMMAND[formatCommand];
+								if (format !== void 0) selection.formatText(format);
+							}
+							event.stopImmediatePropagation();
+						}
+					});
+				}
+			}
+		}
+	}
+}
+/**
+* Add Dragon speech to text input support to the editor, via the
+* \@lexical/dragon module.
+*/
+const DragonExtension = /* @__PURE__ */ defineExtension({
+	build: (editor, config, state) => namedSignals(config),
+	config: /* @__PURE__ */ safeCast({ disabled: typeof window === "undefined" }),
+	name: "@lexical/dragon",
+	register: (editor, config, state) => effect(() => state.getOutput().disabled.value ? void 0 : registerDragonSupport(editor))
+});
+//#endregion
+export { DragonExtension, installDragonSupport, registerDragonSupport };

package/dist/{LexicalDragon.node-BVhw4C7s.mjs → LexicalDragon.node-DLXctJyy.mjs}

@@ -1,4 +1,4 @@
-//#region ../../node_modules/.pnpm/@lexical+dragon@0.45.0/node_modules/@lexical/dragon/dist/LexicalDragon.node.mjs
+//#region ../../node_modules/.pnpm/@lexical+dragon@0.46.0_typescript@6.0.3/node_modules/@lexical/dragon/dist/LexicalDragon.node.mjs
 /**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
@@ -6,8 +6,9 @@
 * LICENSE file in the root directory of this source tree.
 *
 */
-const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalDragon.dev-DwprRH0z.mjs") : import("./LexicalDragon.prod-nh4J-8vn.mjs"));
+const mod = await (process.env.NODE_ENV !== "production" ? import("./LexicalDragon.dev-CqW7Aq5H.mjs") : import("./LexicalDragon.prod-DHI3T6n5.mjs"));
 const DragonExtension = mod.DragonExtension;
+mod.installDragonSupport;
 mod.registerDragonSupport;
 //#endregion
 export { DragonExtension as t };

package/dist/LexicalDragon.prod-DHI3T6n5.mjs

@@ -0,0 +1,121 @@
+import { f as namedSignals, l as effect, m as watchedSignal } from "./LexicalExtension.node-BWH6xbzG.mjs";
+import { Ar as getEditorPropertyFromDOMNode, Cr as getActiveElementDeep, W as $getSelection, Zr as isLexicalEditor, ai as safeCast, br as defineExtension, bt as $isTextNode, pt as $isRangeSelection } from "./Lexical.node-BlCLnfA6.mjs";
+//#region ../../node_modules/.pnpm/@lexical+dragon@0.46.0_typescript@6.0.3/node_modules/@lexical/dragon/dist/LexicalDragon.prod.mjs
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const c = {
+	bold: "bold",
+	italic: "italic",
+	strikeThrough: "strikethrough",
+	subscript: "subscript",
+	superscript: "superscript",
+	underline: "underline"
+}, f = Symbol.for("@lexical/dragon/WindowState");
+function g(e = function() {
+	return "undefined" != typeof window ? window : void 0;
+}()) {
+	return e ? p(e, Symbol("@lexical/dragon/globalInstall"), void 0) : () => {};
+}
+function p(e, t, n) {
+	const i = function(e) {
+		let t = e[f];
+		return void 0 === t && (t = {
+			dispose: () => {},
+			editors: /* @__PURE__ */ new Map(),
+			installs: /* @__PURE__ */ new Set()
+		}, e[f] = t), t;
+	}(e);
+	if (0 === i.installs.size) {
+		const t = x.bind(e);
+		e.addEventListener("message", t, !0), i.dispose = () => {
+			e.removeEventListener("message", t, !0);
+		};
+	}
+	if (i.installs.add(t), n) {
+		const e = i.editors.get(n) || /* @__PURE__ */ new Set();
+		e.add(t), i.editors.set(n, e);
+	}
+	return m.bind(null, e, i, t, n);
+}
+function m(e, t, n, i) {
+	if (i) {
+		const e = t.editors.get(i);
+		e && e.delete(n) && 0 === e.size && t.editors.delete(i);
+	}
+	t.installs.delete(n) && 0 === t.installs.size && (t.dispose(), delete e[f]);
+}
+function y(e) {
+	return e && e.ownerDocument.defaultView;
+}
+function b(n) {
+	const i = watchedSignal(() => y(n.getRootElement()), (e) => n.registerRootListener((t) => {
+		e.value = y(t);
+	}));
+	return effect(() => {
+		const e = i.value;
+		if (e) return p(e, Symbol("@lexical/dragon/editorInstall"), n);
+	});
+}
+function x(e) {
+	if (e.origin !== this.location.origin) return;
+	const t = function(e) {
+		const t = e[f];
+		if (void 0 === t) return null;
+		const n = getEditorPropertyFromDOMNode(getActiveElementDeep(e.document));
+		return isLexicalEditor(n) && t.editors.has(n) ? n : null;
+	}(this);
+	if (null === t) return;
+	const n = e.data;
+	if ("string" == typeof n) {
+		let r;
+		try {
+			r = JSON.parse(n);
+		} catch (e) {
+			return;
+		}
+		if (r && "nuanria_messaging" === r.protocol && "request" === r.type) {
+			const n = r.payload;
+			if (n && "makeChanges" === n.functionId) {
+				const r = n.args;
+				if (Array.isArray(r)) {
+					const [n, l, a, d, u, f] = r;
+					if (![
+						n,
+						l,
+						d,
+						u
+					].every(Number.isFinite) || "string" != typeof a && -1 !== a) return;
+					t.update(() => {
+						const t = $getSelection();
+						if ($isRangeSelection(t)) {
+							const i = t.anchor;
+							let o = i.getNode(), r = 0, g = 0;
+							if ($isTextNode(o) && n >= 0 && l >= 0 && (r = n, g = n + l, t.setTextNodeRange(o, r, o, g)), "string" != typeof a || r === g && "" === a || (t.insertRawText(a), o = i.getNode()), $isTextNode(o)) {
+								const e = o.getTextContentSize();
+								r = Math.min(Math.max(d, 0), e), g = d < 0 || u < 0 ? r : Math.min(d + u, e), t.setTextNodeRange(o, r, o, g);
+							}
+							if ("string" == typeof f && u > 0 && !t.isCollapsed()) {
+								const e = c[f];
+								void 0 !== e && t.formatText(e);
+							}
+							e.stopImmediatePropagation();
+						}
+					});
+				}
+			}
+		}
+	}
+}
+const h = /* @__PURE__ */ defineExtension({
+	build: (e, t, i) => namedSignals(t),
+	config: /* @__PURE__ */ safeCast({ disabled: "undefined" == typeof window }),
+	name: "@lexical/dragon",
+	register: (e, n, i) => effect(() => i.getOutput().disabled.value ? void 0 : b(e))
+});
+//#endregion
+export { h as DragonExtension, g as installDragonSupport, b as registerDragonSupport };