@octane-xplat/tiptap 0.0.1 → 0.10.0

package/dist/native/index.js

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

package/dist/native/index2.js

@@ -0,0 +1,82 @@
+//#region src/json-bridge.ts
+var bridge;
+/** zeed-dom's classList is a plain {contains,add,remove} object; tiptap's
+*  codeBlock parseHTML spreads it. Wrap the VElement getter so it hands back
+*  an iterable array that keeps the mutation methods. */
+function patchClassList(VElement) {
+	const proto = VElement?.prototype;
+	if (!proto) throw new Error("VElement.prototype unavailable");
+	const desc = Object.getOwnPropertyDescriptor(proto, "classList");
+	if (!desc?.get) throw new Error("classList is not a prototype getter");
+	if (desc.get.__xplatPatched) return;
+	const patched = function() {
+		const cl = desc.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;
+	};
+	patched.__xplatPatched = true;
+	Object.defineProperty(proto, "classList", {
+		configurable: true,
+		get: patched,
+		set: desc.set
+	});
+}
+/** Install the minimal parse globals generateJSON's elementFromString
+*  reads. Only installs when the host lacks them, so a real DOM (web
+*  target) is never clobbered. */
+function installDomShim(zeed) {
+	const g = globalThis;
+	if (g.window?.DOMParser) return;
+	class ZeedDOMParser {
+		parseFromString(html) {
+			const doc = zeed.createHTMLDocument();
+			doc.body.innerHTML = html;
+			return doc;
+		}
+	}
+	g.window = { DOMParser: ZeedDOMParser };
+	g.document = zeed.createHTMLDocument();
+}
+async function ensureJSONBridge() {
+	if (bridge !== void 0) return bridge !== null;
+	try {
+		const [core, sk, sr, zeed] = await Promise.all([
+			import("@tiptap/core"),
+			import("@tiptap/starter-kit"),
+			import("@tiptap/static-renderer"),
+			import("zeed-dom")
+		]);
+		patchClassList(zeed.VElement);
+		installDomShim(zeed);
+		const StarterKit = sk.default ?? sk.StarterKit;
+		bridge = {
+			generateJSON: core.generateJSON,
+			renderToHTMLString: sr.renderToHTMLString,
+			extensions: [StarterKit]
+		};
+		return true;
+	} catch {
+		bridge = null;
+		return false;
+	}
+}
+/** HTML → doc JSON through tiptap's own parseHTML rules. Null when the
+*  bridge hasn't loaded (call ensureJSONBridge first / check `ready`). */
+function htmlToJSON(html) {
+	return bridge?.generateJSON(html, bridge.extensions) ?? null;
+}
+/** Doc JSON → HTML via tiptap's own renderHTML rules (no DOM). */
+function jsonToHTML(doc) {
+	return bridge?.renderToHTMLString({
+		extensions: bridge.extensions,
+		content: doc
+	}) ?? null;
+}
+function jsonBridgeReady() {
+	return bridge != null;
+}
+//#endregion
+export { ensureJSONBridge, htmlToJSON, jsonBridgeReady, jsonToHTML };

package/dist/native/index3.js

@@ -0,0 +1,211 @@
+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/TiptapEditor.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(8);
+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 __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var supported$1 = supported;
+var TiptapEditor = defineUniversalComponent("nativescript", function TiptapEditor(props) {
+	const inner = useRef(null, _h$0);
+	const [exposedHandle, setHandle] = useState(null, _h$1);
+	useImperativeHandle(props.ref, () => exposedHandle, [exposedHandle], _h$2);
+	const jsonReady = useRef(false, _h$3);
+	const lastJSON = useRef(void 0, _h$4);
+	const bindHost = useCallback((h) => {
+		inner.current = h;
+		setHandle((previous) => previous?.native === h?.native ? previous : h ? {
+			getHTML: () => h.getHTML(),
+			setHTML: (html) => h.setHTML(html),
+			getJSON: () => jsonBridgeReady() ? htmlToJSON(h.getHTML()) : null,
+			setJSON: (doc) => {
+				const html = jsonBridgeReady() ? jsonToHTML(doc) : null;
+				if (html != null) {
+					lastJSON.current = JSON.stringify(doc);
+					h.setHTML(html);
+				}
+			},
+			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$5);
+	useEffect(() => {
+		ensureJSONBridge().then((ok) => {
+			jsonReady.current = ok;
+			props.onJSONReady?.(ok);
+		});
+	}, [], _h$6);
+	useEffect(() => {
+		if (!props.json || !jsonBridgeReady() || !inner.current) return;
+		const stamp = JSON.stringify(props.json);
+		if (stamp === lastJSON.current) return;
+		const html = jsonToHTML(props.json);
+		if (html != null) {
+			lastJSON.current = stamp;
+			inner.current.setHTML(html);
+		}
+	}, [props.json], _h$7);
+	const emitJSON = () => {
+		if (!inner.current || !jsonBridgeReady()) return;
+		const doc = htmlToJSON(inner.current.getHTML());
+		if (doc) {
+			lastJSON.current = JSON.stringify(doc);
+			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",
+			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 { TiptapEditor, supported$1 as supported };

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

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "3880e698-2b9a-436f-af5a-a7ec180643bf",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}

package/dist/web/index.js

@@ -0,0 +1,12 @@
+import { TiptapEditor, supported } from "./index2.js";
+//#region src/index.web.ts
+/** Web needs no lazy bridge — tiptap 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 { TiptapEditor, ensureJSONBridge, jsonBridgeReady, supported };

package/dist/web/index2.js

@@ -0,0 +1,183 @@
+import { __s, bag3, clone, componentSlot, hookSlots, setStyle, template, useEffect, useImperativeHandle, useRef, withSlot } from "octane";
+import { updateFreshClassName } from "octane/internal/client";
+import { EditorContent, useEditor } from "@octanejs/tiptap";
+import StarterKit from "@tiptap/starter-kit";
+//#region src/TiptapEditor.web.tsrx
+var _t$0 = /* @__PURE__ */ template("<div></div>");
+var _hs$ = /* @__PURE__ */ hookSlots(10);
+var _h$5 = /* @__PURE__ */ Symbol(_hs$ + 5);
+var supported = true;
+var COMMAND = {
+	bold: (c) => c.toggleBold(),
+	italic: (c) => c.toggleItalic(),
+	underline: (c) => c.toggleUnderline(),
+	strikethrough: (c) => c.toggleStrike(),
+	code: (c) => c.toggleCode(),
+	blockquote: (c) => c.toggleBlockquote(),
+	bulletList: (c) => c.toggleBulletList(),
+	orderedList: (c) => c.toggleOrderedList(),
+	codeBlock: (c) => c.toggleCodeBlock(),
+	horizontalRule: (c) => c.setHorizontalRule(),
+	paragraph: (c) => c.setParagraph(),
+	heading1: (c) => c.toggleHeading({ level: 1 }),
+	heading2: (c) => c.toggleHeading({ level: 2 }),
+	heading3: (c) => c.toggleHeading({ level: 3 }),
+	heading4: (c) => c.toggleHeading({ level: 4 }),
+	heading5: (c) => c.toggleHeading({ level: 5 }),
+	heading6: (c) => c.toggleHeading({ level: 6 })
+};
+var ACTIVE_OF = [
+	["bold", "bold"],
+	["italic", "italic"],
+	["underline", "underline"],
+	["strikethrough", "strike"],
+	["code", "code"],
+	["blockquote", "blockquote"],
+	["bulletList", "bulletList"],
+	["orderedList", "orderedList"],
+	["codeBlock", "codeBlock"],
+	["link", "link"],
+	[
+		"heading1",
+		"heading",
+		{ level: 1 }
+	],
+	[
+		"heading2",
+		"heading",
+		{ level: 2 }
+	],
+	[
+		"heading3",
+		"heading",
+		{ level: 3 }
+	],
+	[
+		"heading4",
+		"heading",
+		{ level: 4 }
+	],
+	[
+		"heading5",
+		"heading",
+		{ level: 5 }
+	],
+	[
+		"heading6",
+		"heading",
+		{ level: 6 }
+	],
+	["paragraph", "paragraph"]
+];
+function activeFormats(editor) {
+	const out = [];
+	for (const [name, kind, attrs] of ACTIVE_OF) if (editor.isActive(kind, attrs)) out.push(name);
+	return out;
+}
+var TiptapEditor = /* @__PURE__ */ __s(function TiptapEditor(props, __s, __extra) {
+	const lastEmitted = useRef(void 0, _hs$ + 0);
+	const lastJSON = useRef(void 0, _hs$ + 1);
+	const lastHTMLInput = useRef(JSON.stringify([props.json !== void 0, props.value]), _hs$ + 2);
+	const lastJSONInput = useRef(JSON.stringify(props.json), _hs$ + 3);
+	const bound = useRef(void 0, _hs$ + 4);
+	const editor = withSlot(_h$5, useEditor, {
+		extensions: [StarterKit],
+		content: props.json ?? props.value ?? "",
+		editable: props.editable !== false,
+		autofocus: props.autofocus ?? false,
+		onCreate: () => props.onReady?.(),
+		onUpdate: ({ editor: e }) => {
+			const html = e.getHTML();
+			lastEmitted.current = html;
+			props.onChange?.(html);
+			const doc = e.getJSON();
+			lastJSON.current = JSON.stringify(doc);
+			props.onJSONChange?.(doc);
+		},
+		onFocus: () => props.onFocus?.(),
+		onBlur: () => props.onBlur?.(),
+		onSelectionUpdate: ({ editor: e }) => props.onSelectionChange?.({
+			start: e.state.selection.from,
+			end: e.state.selection.to,
+			active: activeFormats(e)
+		})
+	});
+	useEffect(() => {
+		if (!editor) return;
+		const stamp = JSON.stringify([props.json !== void 0, props.value]);
+		if (stamp === lastHTMLInput.current) return;
+		lastHTMLInput.current = stamp;
+		if (props.value === void 0 || props.json !== void 0) return;
+		if (props.value === lastEmitted.current) return;
+		editor.commands.setContent(props.value);
+	}, [
+		editor,
+		props.value,
+		props.json
+	], _hs$ + 6);
+	useEffect(() => {
+		if (!editor) return;
+		const stamp = JSON.stringify(props.json);
+		if (stamp === lastJSONInput.current) return;
+		lastJSONInput.current = stamp;
+		if (props.json === void 0 || stamp === lastJSON.current) return;
+		editor.commands.setContent(props.json);
+	}, [editor, props.json], _hs$ + 7);
+	useEffect(() => {
+		if (!editor) return;
+		editor.setEditable(props.editable !== false);
+	}, [editor, props.editable], _hs$ + 8);
+	useImperativeHandle(props.ref, () => {
+		if (!editor) return null;
+		const e = editor;
+		bound.current = {
+			getHTML: () => e.getHTML(),
+			setHTML: (html) => e.commands.setContent(html),
+			getJSON: () => e.getJSON(),
+			setJSON: (doc) => e.commands.setContent(doc),
+			apply: (format) => {
+				const run = COMMAND[format];
+				if (run) run(e.chain().focus()).run();
+			},
+			linkTo: (url, anchor) => {
+				if (anchor != null && anchor !== "") e.chain().focus().insertContent({
+					type: "text",
+					text: anchor,
+					marks: [{
+						type: "link",
+						attrs: { href: url }
+					}]
+				}).run();
+				else e.chain().focus().extendMarkRange("link").setLink({ href: url }).run();
+			},
+			removeLink: () => e.chain().focus().unsetLink().run(),
+			isActive: (format) => activeFormats(e).includes(format),
+			undo: () => e.commands.undo(),
+			redo: () => e.commands.redo(),
+			focus: () => e.commands.focus(),
+			blur: () => e.commands.blur(),
+			isFocused: () => e.isFocused,
+			native: e
+		};
+		return bound.current;
+	}, [editor], _hs$ + 9);
+	if (__s.block.pending && !__s.block.crossRenderUpdate) return;
+	let _b = __s.slots[0];
+	if (_b === void 0) {
+		let _m1;
+		const _root = clone(_t$0);
+		_m1 = _root;
+		_b = bag3(__s, _root, void 0, _m1, void 0);
+	}
+	_b.a = updateFreshClassName(["vx-richtext", props.className], _b.a, _b.b);
+	{
+		const _v = props.style;
+		if (_b.c !== _v) {
+			setStyle(_b.b, _v, _b.c);
+			_b.c = _v;
+		}
+	}
+	componentSlot(__s, 1, _b.b, EditorContent, { "editor": editor }, void 0, void 0, 2, void 0, void 0, "c:e9be3bbb");
+});
+//#endregion
+export { TiptapEditor, supported };

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

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "e01adeb4-b2cd-4b21-9fdd-57831df35c5b",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}

package/package.json

@@ -1,19 +1,93 @@
 {
   "name": "@octane-xplat/tiptap",
-  "version": "0.0.1",
-  "description": "Unified rich-text editor facade for Octane xplat — @octanejs/tiptap on web, @octane-xplat/richtext (Aztec) + tiptap doc model on native",
+  "version": "0.10.0",
+  "description": "Unified rich-text editor facade for Octane xplat — live tiptap on web/AppKit, Aztec + tiptap document model on Android",
+  "keywords": [
+    "cross-platform",
+    "editor",
+    "octane",
+    "prosemirror",
+    "rich-text",
+    "richtext",
+    "tiptap",
+    "xplat"
+  ],
+  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/tiptap",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/octane-xplat/octane-xplat.git",
+    "url": "https://github.com/octane-xplat/octane-xplat",
     "directory": "packages/tiptap"
   },
-  "homepage": "https://github.com/octane-xplat/octane-xplat/tree/main/packages/tiptap",
-  "main": "./index.js",
-  "types": "./index.d.ts",
   "files": [
-    "README.md",
-    "index.js",
-    "index.d.ts"
-  ]
-}
+    "dist",
+    "types",
+    "src",
+    "platforms"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "macos": {
+        "types": "./types/index.macos.d.ts",
+        "default": "./src/index.macos.ts"
+      },
+      "web": {
+        "types": "./types/index.d.ts",
+        "default": "./dist/web/index.js"
+      },
+      "native": {
+        "types": "./types/index.d.ts",
+        "default": "./dist/native/index.js"
+      },
+      "types": "./types/index.d.ts",
+      "default": "./dist/native/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@octane-xplat/richtext": "0.10.0",
+    "@octanejs/tiptap": "0.0.51",
+    "@tiptap/core": "3.28.0",
+    "@tiptap/pm": "3.28.0",
+    "@tiptap/starter-kit": "3.28.0",
+    "@tiptap/static-renderer": "3.28.0",
+    "zeed-dom": "^0.15.1"
+  },
+  "devDependencies": {
+    "@nativescript-community/octane": "0.2.4",
+    "@nativescript/core": "9.1.2",
+    "@octane-xplat/macos-renderer": "0.10.0",
+    "@octanejs/vite-plugin": "0.1.61",
+    "octane": "0.6.3",
+    "typescript": "5.9.3",
+    "vite": "8.3.0"
+  },
+  "peerDependencies": {
+    "@nativescript-community/octane": ">=0.2.1 <1",
+    "@nativescript/core": ">=9.1.0 <10",
+    "octane": ">=0.6.3 <1"
+  },
+  "peerDependenciesMeta": {
+    "@nativescript-community/octane": {
+      "optional": true
+    },
+    "@nativescript/core": {
+      "optional": true
+    },
+    "octane": {
+      "optional": true
+    }
+  },
+  "nativescript": {
+    "platforms": {
+      "android": "9.1.0",
+      "ios": "9.1.0"
+    }
+  },
+  "scripts": {
+    "build": "vite build && vite build --mode native && tsc -p tsconfig.types.json && node ../../scripts/check-native-dist.mjs && node ../richtext/build-browser.mjs"
+  }
+}

package/src/Editor.macos.tsx

@@ -0,0 +1,9 @@
+/** @jsxImportSource @octane-xplat/macos-renderer */
+import type { TiptapEditorProps } from './types'
+import browser from '../dist/macos/browser.js'
+import { NativeEditor } from '@octane-xplat/richtext/macos-host'
+
+/** AppKit mounts the local editor engine in WKWebView. */
+export function TiptapEditor(props: TiptapEditorProps) {
+	return <NativeEditor {...props} browser={browser} />
+}