@octane-xplat/lexical 0.0.1 → 0.11.0

package/dist/native/index.js

@@ -0,0 +1,3 @@
+import { ensureJSONBridge, jsonBridgeReady } from "./index2.js";
+import { LexicalEditor, supported } from "./index3.js";
+export { LexicalEditor, ensureJSONBridge, jsonBridgeReady, supported };

package/dist/native/index2.js

@@ -0,0 +1,232 @@
+//#region src/json-bridge.ts
+var bridge;
+var kebab = (k) => k.replace(/[A-Z]/g, (c) => "-" + c.toLowerCase());
+function chainDesc(proto, key) {
+	let o = proto;
+	while (o && o !== Object.prototype) {
+		const d = Object.getOwnPropertyDescriptor(o, key);
+		if (d) return d;
+		o = Object.getPrototypeOf(o);
+	}
+}
+function cssText(el) {
+	return el.getAttribute("style") ?? "";
+}
+function writeStyleProp(el, key, value) {
+	const rules = cssText(el).split(";").map((s) => s.trim()).filter(Boolean).filter((r) => !r.startsWith(kebab(key) + ":"));
+	if (value !== "" && value != null) rules.push(`${kebab(key)}: ${value}`);
+	el.setAttribute("style", rules.join("; "));
+}
+/** zeed-dom is a vdom, not a DOM — lexical's walkers and exportDOM need four
+*  categories of patches beyond the classList/DOMParser install the tiptap
+*  bridge carries:
+*
+*  1. `parentElement` (absent pre-0.18 zeed-dom; guarded either way).
+*  2. `firstChild`/`lastChild`/sibling accessors return `undefined` where the
+*     DOM spec says `null`, and the getters live on an ancestor proto —
+*     chainDesc finds them so the coercion wraps the real getter.
+*  3. `style`: DOM reads of unset props return `''`, and lexical's exportDOM
+*     writes via property assignment and `setProperty` — neither serializes
+*     in zeed. The proxy defaults missing props to `''` and writes through
+*     to the element's `style` attribute.
+*  4. Attribute-valued property assignments (`element.href = …`) must land
+*     as attributes — LinkNode.exportDOM sets `anchor.href`, dropping the
+*     link target entirely without this.
+*
+*  Plus the `Node` constants global (lexical's helpers read
+*  `Node.TEXT_NODE`). */
+function installLexicalDomShim(zeed) {
+	const bootDoc = zeed.createHTMLDocument();
+	bootDoc.body.innerHTML = "<p>x</p>";
+	const elProto = Object.getPrototypeOf(bootDoc.body.childNodes[0]);
+	const textProto = Object.getPrototypeOf(bootDoc.body.childNodes[0].childNodes[0]);
+	for (const p of [elProto, textProto]) {
+		if (!chainDesc(p, "parentElement")) Object.defineProperty(p, "parentElement", {
+			configurable: true,
+			get() {
+				const par = this.parentNode;
+				return par && par.nodeType === 1 ? par : null;
+			}
+		});
+		for (const k of [
+			"firstChild",
+			"lastChild",
+			"nextSibling",
+			"previousSibling"
+		]) {
+			const d = chainDesc(p, k);
+			Object.defineProperty(p, k, {
+				configurable: true,
+				get() {
+					return (d?.get ? d.get.call(this) : void 0) ?? null;
+				},
+				set: d?.set
+			});
+		}
+	}
+	const styleCache = /* @__PURE__ */ new WeakMap();
+	Object.defineProperty(elProto, "style", {
+		configurable: true,
+		get() {
+			let proxy = styleCache.get(this);
+			if (!proxy) {
+				const el = this;
+				proxy = new Proxy({}, {
+					get: (_t, k) => {
+						if (k === "setProperty") return (prop, value) => writeStyleProp(el, prop, value);
+						if (k === "removeProperty") return (prop) => {
+							writeStyleProp(el, prop, "");
+							return "";
+						};
+						if (k === "cssText") return cssText(el);
+						if (k === "getPropertyValue") return (prop) => {
+							const raw = cssText(el).split(";").map((s) => s.trim()).find((r) => r.startsWith(prop + ":"));
+							return raw ? raw.slice(raw.indexOf(":") + 1).trim() : "";
+						};
+						if (typeof k === "string") {
+							const raw = cssText(el).split(";").map((s) => s.trim()).find((r) => r.startsWith(kebab(k) + ":"));
+							return raw ? raw.slice(raw.indexOf(":") + 1).trim() : "";
+						}
+					},
+					set: (_t, k, v) => {
+						if (typeof k === "string") writeStyleProp(el, k, v);
+						return true;
+					}
+				});
+				styleCache.set(this, proxy);
+			}
+			return proxy;
+		}
+	});
+	for (const attr of [
+		"href",
+		"target",
+		"rel",
+		"title"
+	]) {
+		const d = chainDesc(elProto, attr);
+		if (!d?.get && !d?.set) Object.defineProperty(elProto, attr, {
+			configurable: true,
+			get() {
+				return this.getAttribute(attr) ?? "";
+			},
+			set(v) {
+				this.setAttribute(attr, v);
+			}
+		});
+	}
+	const clDesc = chainDesc(elProto, "classList");
+	if (clDesc?.get) Object.defineProperty(elProto, "classList", {
+		configurable: true,
+		get() {
+			const cl = clDesc.get.call(this);
+			if (cl && typeof cl[Symbol.iterator] !== "function") {
+				const tokens = String(this.getAttribute("class") ?? "").split(/\s+/).filter(Boolean);
+				return Object.assign(tokens, cl);
+			}
+			return cl;
+		},
+		set: clDesc.set
+	});
+	const g = globalThis;
+	if (!g.window?.DOMParser) {
+		class ZeedDOMParser {
+			parseFromString(html) {
+				const doc = zeed.createHTMLDocument();
+				doc.body.innerHTML = html;
+				return doc;
+			}
+		}
+		g.window = { DOMParser: ZeedDOMParser };
+		g.document = zeed.createHTMLDocument();
+	}
+	g.Node = g.Node ?? {
+		ELEMENT_NODE: 1,
+		ATTRIBUTE_NODE: 2,
+		TEXT_NODE: 3,
+		CDATA_SECTION_NODE: 4,
+		PROCESSING_INSTRUCTION_NODE: 7,
+		COMMENT_NODE: 8,
+		DOCUMENT_NODE: 9,
+		DOCUMENT_TYPE_NODE: 10,
+		DOCUMENT_FRAGMENT_NODE: 11
+	};
+}
+async function ensureJSONBridge() {
+	if (bridge !== void 0) return bridge !== null;
+	try {
+		const [lexical, html, rt, list, link, code, ext, zeed] = await Promise.all([
+			import("lexical"),
+			import("@lexical/html"),
+			import("@lexical/rich-text"),
+			import("@lexical/list"),
+			import("@lexical/link"),
+			import("@lexical/code"),
+			import("@lexical/extension"),
+			import("zeed-dom")
+		]);
+		installLexicalDomShim(zeed);
+		bridge = {
+			editor: lexical.createEditor({
+				namespace: "octane-xplat/lexical",
+				nodes: [
+					rt.HeadingNode,
+					rt.QuoteNode,
+					list.ListNode,
+					list.ListItemNode,
+					link.LinkNode,
+					code.CodeNode,
+					ext.HorizontalRuleNode
+				],
+				onError: () => void 0
+			}),
+			lexical,
+			html,
+			zeed
+		};
+		return true;
+	} catch {
+		bridge = null;
+		return false;
+	}
+}
+function jsonBridgeReady() {
+	return bridge != null;
+}
+function parseHTML(htmlText) {
+	const doc = bridge.zeed.createHTMLDocument();
+	doc.body.innerHTML = htmlText;
+	return doc;
+}
+/** HTML → serialized editor state through lexical's own DOM import rules.
+*  Null when the bridge hasn't loaded (call ensureJSONBridge first / check
+*  `jsonBridgeReady`). */
+function htmlToJSON(htmlText) {
+	if (!bridge) return null;
+	try {
+		bridge.editor.update(() => {
+			const nodes = bridge.html.$generateNodesFromDOM(bridge.editor, parseHTML(htmlText));
+			bridge.lexical.$getRoot().clear().append(...nodes);
+		}, { discrete: true });
+		return bridge.editor.getEditorState().toJSON();
+	} catch {
+		return null;
+	}
+}
+/** Serialized editor state → HTML via lexical's own exportDOM rules (no
+*  browser DOM — the zeed-dom shim stands in). */
+function jsonToHTML(doc) {
+	if (!bridge) return null;
+	try {
+		bridge.editor.setEditorState(bridge.editor.parseEditorState(JSON.stringify(doc)));
+		let out = "";
+		bridge.editor.read(() => {
+			out = bridge.html.$generateHtmlFromNodes(bridge.editor);
+		});
+		return out;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { ensureJSONBridge, htmlToJSON, jsonBridgeReady, jsonToHTML };

package/dist/native/index3.js

@@ -0,0 +1,228 @@
+import { ensureJSONBridge, htmlToJSON, jsonBridgeReady, jsonToHTML } from "./index2.js";
+import { defineUniversalComponent, hookSlots, universalComponent, universalPlan, universalProps, universalValue, useCallback, useEffect, useImperativeHandle, useRef, useState } from "@nativescript-community/octane";
+import { RichTextEditor, supported } from "@octane-xplat/richtext";
+//#region src/LexicalEditor.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(9);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
+var _h$4 = /* @__PURE__ */ Symbol(_hs$ + 4);
+var _h$5 = /* @__PURE__ */ Symbol(_hs$ + 5);
+var _h$6 = /* @__PURE__ */ Symbol(_hs$ + 6);
+var _h$7 = /* @__PURE__ */ Symbol(_hs$ + 7);
+var _h$8 = /* @__PURE__ */ Symbol(_hs$ + 8);
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var supported$1 = supported;
+var LexicalEditor = defineUniversalComponent("nativescript", function LexicalEditor(props) {
+	const inner = useRef(null, _h$0);
+	const [exposedHandle, setHandle] = useState(null, _h$1);
+	useImperativeHandle(props.ref, () => exposedHandle, [exposedHandle], _h$2);
+	const lastJSON = useRef(void 0, _h$3);
+	const appliedHost = useRef(null, _h$4);
+	const desiredDoc = useRef(void 0, _h$5);
+	const applyDoc = () => {
+		const host = inner.current;
+		const doc = desiredDoc.current;
+		if (!host || doc === void 0 || !jsonBridgeReady()) return;
+		const stamp = JSON.stringify(doc);
+		if (stamp === lastJSON.current && appliedHost.current === host) return;
+		const html = jsonToHTML(doc);
+		if (html != null) {
+			lastJSON.current = stamp;
+			appliedHost.current = host;
+			host.setHTML(html);
+		}
+	};
+	const bindHost = useCallback((h) => {
+		inner.current = h;
+		if (h) queueMicrotask(applyDoc);
+		setHandle((previous) => previous?.native === h?.native ? previous : h ? {
+			getHTML: () => h.getHTML(),
+			setHTML: (html) => h.setHTML(html),
+			getJSON: () => jsonBridgeReady() ? htmlToJSON(h.getHTML()) : null,
+			setJSON: (doc) => {
+				desiredDoc.current = doc;
+				applyDoc();
+			},
+			apply: (format) => h.apply(format),
+			linkTo: (url, anchor) => h.linkTo(url, anchor),
+			removeLink: () => h.removeLink(),
+			isActive: (format) => h.isActive(format),
+			undo: () => h.undo(),
+			redo: () => h.redo(),
+			focus: () => h.focus(),
+			blur: () => h.blur(),
+			isFocused: () => h.isFocused(),
+			native: h.native
+		} : null);
+	}, [], _h$6);
+	useEffect(() => {
+		let alive = true;
+		ensureJSONBridge().then((ok) => {
+			if (!alive) return;
+			props.onJSONReady?.(ok);
+			applyDoc();
+		});
+		return () => {
+			alive = false;
+		};
+	}, [], _h$7);
+	useEffect(() => {
+		if (!props.json) return;
+		desiredDoc.current = props.json;
+		applyDoc();
+	}, [props.json], _h$8);
+	const emitJSON = () => {
+		if (!inner.current || !jsonBridgeReady()) return;
+		const doc = htmlToJSON(inner.current.getHTML());
+		if (doc) {
+			lastJSON.current = JSON.stringify(doc);
+			appliedHost.current = inner.current;
+			props.onJSONChange?.(doc);
+		}
+	};
+	return universalValue(__octaneUniversalPlan0, [universalComponent("nativescript", RichTextEditor, universalProps([
+		[
+			"set",
+			"id",
+			props.id
+		],
+		[
+			"set",
+			"className",
+			props.className
+		],
+		[
+			"set",
+			"style",
+			props.style
+		],
+		[
+			"set",
+			"value",
+			props.value
+		],
+		[
+			"set",
+			"placeholder",
+			props.placeholder
+		],
+		[
+			"set",
+			"editable",
+			props.editable
+		],
+		[
+			"set",
+			"autofocus",
+			props.autofocus
+		],
+		[
+			"set",
+			"onReady",
+			() => {
+				applyDoc();
+				props.onReady?.();
+			}
+		],
+		[
+			"set",
+			"onChange",
+			(html) => {
+				props.onChange?.(html);
+				emitJSON();
+			}
+		],
+		[
+			"set",
+			"onSelectionChange",
+			props.onSelectionChange
+		],
+		[
+			"set",
+			"onFocus",
+			props.onFocus
+		],
+		[
+			"set",
+			"onBlur",
+			props.onBlur
+		],
+		[
+			"set",
+			"ref",
+			bindHost
+		],
+		[
+			"set",
+			"android",
+			props.android
+		],
+		[
+			"set",
+			"ios",
+			props.ios
+		],
+		[
+			"set",
+			"row",
+			props.row
+		],
+		[
+			"set",
+			"col",
+			props.col
+		],
+		[
+			"set",
+			"rowSpan",
+			props.rowSpan
+		],
+		[
+			"set",
+			"colSpan",
+			props.colSpan
+		],
+		[
+			"set",
+			"dock",
+			props.dock
+		],
+		[
+			"set",
+			"left",
+			props.left
+		],
+		[
+			"set",
+			"top",
+			props.top
+		],
+		[
+			"set",
+			"flexGrow",
+			props.flexGrow
+		],
+		[
+			"set",
+			"flexShrink",
+			props.flexShrink
+		],
+		[
+			"set",
+			"alignSelf",
+			props.alignSelf
+		],
+		[
+			"set",
+			"order",
+			props.order
+		]
+	]))]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+export { LexicalEditor, supported$1 as supported };

package/dist/native/octane-client-build.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "0e9b3b59-08fe-4f74-9dd5-4ebc5fe298b3",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}

package/dist/web/index.js

@@ -0,0 +1,12 @@
+import { LexicalEditor, supported } from "./index2.js";
+//#region src/index.web.ts
+/** Web needs no lazy bridge — lexical is in the bundle already. Kept for
+*  call-site parity with the native entry. */
+function ensureJSONBridge() {
+	return Promise.resolve(true);
+}
+function jsonBridgeReady() {
+	return true;
+}
+//#endregion
+export { LexicalEditor, ensureJSONBridge, jsonBridgeReady, supported };