@langeditor/plugin-docx 1.0.0

package/dist/chunks/rolldown-runtime-DldpqzEl.js

@@ -0,0 +1,16 @@
+//#region \0rolldown/runtime.js
+var e = Object.create, t = Object.defineProperty, n = Object.getOwnPropertyDescriptor, r = Object.getOwnPropertyNames, i = Object.getPrototypeOf, a = Object.prototype.hasOwnProperty, o = (e, t) => () => (t || (e((t = { exports: {} }).exports, t), e = null), t.exports), s = (e, i, o, s) => {
+	if (i && typeof i == "object" || typeof i == "function") for (var c = r(i), l = 0, u = c.length, d; l < u; l++) d = c[l], !a.call(e, d) && d !== o && t(e, d, {
+		get: ((e) => i[e]).bind(null, d),
+		enumerable: !(s = n(i, d)) || s.enumerable
+	});
+	return e;
+}, c = (n, r, o) => (o = n == null ? {} : e(i(n)), s(r || !n || !n.__esModule || !a.call(n, "default") ? t(o, "default", {
+	value: n,
+	enumerable: !0
+}) : o, n)), l = /* @__PURE__ */ ((e) => typeof require < "u" ? require : typeof Proxy < "u" ? new Proxy(e, { get: (e, t) => (typeof require < "u" ? require : e)[t] }) : e)(function(e) {
+	if (typeof require < "u") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + e + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { l as n, c as r, o as t };

package/dist/extensions/ExportWord/ExportWord.d.ts

@@ -0,0 +1,19 @@
+import { Extension, GeneralOptions } from '../../../../..';
+import { ExportDocxOptions } from './docx';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        exportWord: {
+            exportToWord: (fileName?: string) => ReturnType;
+        };
+    }
+}
+export interface ExportWordOptions extends GeneralOptions<ExportWordOptions>, ExportDocxOptions {
+    fileName: string;
+}
+export declare const ExportWord: Extension<ExportWordOptions, any>;
+/**
+ * Lazily loads the DOCX serializer for consumers that need direct access.
+ * Keeping this wrapper async prevents Word dependencies from entering the
+ * editor's initial bundle.
+ */
+export declare function createDocxDocument(...args: Parameters<(typeof import('./docx'))['createDocxDocument']>): Promise<import('docx').Document>;

package/dist/extensions/ExportWord/docx.d.ts

@@ -0,0 +1,6 @@
+import { EditorInstance as Editor, WordComment } from '../../../../..';
+export interface ExportDocxOptions {
+    resolveImage?: (src: string) => Promise<Uint8Array>;
+    comments?: WordComment[];
+}
+export declare function createDocxDocument(editor: Editor, options?: ExportDocxOptions): Promise<import('docx').Document>;

package/dist/extensions/ExportWord/fallback.d.ts

@@ -0,0 +1,24 @@
+import { Node as ProseMirrorNode } from '@tiptap/pm/model';
+export interface WordExportFallbackContent {
+    title: string;
+    description?: string;
+    href?: string;
+    actionLabel?: string;
+}
+export interface WordExportFallbackDefinition {
+    /** Stable globally unique registration ID. */
+    id: string;
+    /** Tiptap node type handled by this fallback. */
+    nodeType: string;
+    /** Resolves a portable, non-interactive representation for DOCX output. */
+    resolve: (node: ProseMirrorNode) => WordExportFallbackContent | null;
+}
+/**
+ * Registers a portable DOCX fallback for one plugin-owned Tiptap node.
+ *
+ * The fallback is intentionally data-only. It keeps commercial and optional
+ * packages independent from the DOCX runtime while ensuring unsupported nodes
+ * never disappear or fail export without a useful representation.
+ */
+export declare function registerWordExportFallback(definition: WordExportFallbackDefinition): () => void;
+export declare function getWordExportFallbacks(): WordExportFallbackDefinition[];

package/dist/extensions/ExportWord/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ExportWord';
+export * from './fallback';

package/dist/extensions/ImportWord/ImportWord.d.ts

@@ -0,0 +1,20 @@
+import { Extension, GeneralOptions } from '../../../../..';
+export interface WordImageUploadResult {
+    src: string;
+}
+export interface ImportWordOptions extends GeneralOptions<ImportWordOptions> {
+    /** Uploads imported DOCX images and returns their stable application URLs. */
+    upload?: (files: File[]) => Promise<WordImageUploadResult[]>;
+    /** Maximum DOCX size accepted by the browser parser. */
+    limit: number;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        importWord: {
+            toggleImportWord: () => ReturnType;
+        };
+    }
+}
+export declare const ImportWord: Extension<ImportWordOptions, any>;
+/** Lazily loads the DOCX parser for direct consumers. */
+export declare function parseDocx(...args: Parameters<(typeof import('./docx'))['parseDocx']>): Promise<import('./docx').DocxImportResult>;

package/dist/extensions/ImportWord/docx.d.ts

@@ -0,0 +1,13 @@
+import { JSONContent, WordComment } from '../../../../..';
+export interface DocxImageAsset {
+    file: File;
+    dataUrl: string;
+    target: string;
+}
+export interface DocxImportResult {
+    content: JSONContent;
+    images: DocxImageAsset[];
+    comments: WordComment[];
+    warnings: string[];
+}
+export declare function parseDocx(file: File): Promise<DocxImportResult>;

package/dist/extensions/ImportWord/index.d.ts

@@ -0,0 +1 @@
+export * from './ImportWord';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './manifest';
+export * from './plugin';
+export * from './extensions/ExportWord';
+export * from './extensions/ImportWord';

package/dist/index.es.js

@@ -0,0 +1,226 @@
+import { ActionButton as e, Extension as t, registerEditorPlugin as n, useLocale as r, useToast as i } from "@langeditor/core";
+import { computed as a, getCurrentScope as o, onScopeDispose as s, readonly as c, ref as l, toValue as u, watchEffect as d } from "vue";
+//#region src/extensions/ExportWord/ExportWord.ts
+function f(e, t) {
+	let n = URL.createObjectURL(e), r = document.createElement("a");
+	r.href = n, r.download = t, r.click(), queueMicrotask(() => URL.revokeObjectURL(n));
+}
+var p = t.create({
+	name: "exportWord",
+	addOptions() {
+		return {
+			...this.parent?.(),
+			fileName: "document.docx",
+			resolveImage: void 0,
+			button: ({ editor: t, t: n }) => ({
+				component: e,
+				componentProps: {
+					action: () => t.commands.exportToWord(),
+					icon: "FileDown",
+					tooltip: n("editor.exportWord.tooltip")
+				}
+			})
+		};
+	},
+	addCommands() {
+		return { exportToWord: (e) => ({ editor: t }) => (Promise.all([import("./chunks/dist-CCgJdXY1.js"), import("./chunks/docx-LNMvqtvT.js")]).then(async ([{ Packer: e }, { createDocxDocument: n }]) => e.toBlob(await n(t, this.options))).then((t) => {
+			if (!t.size) throw Error("The Word document is empty");
+			f(t, e || this.options.fileName);
+		}).catch((e) => console.error("Failed to export Word document:", e)), !0) };
+	}
+});
+async function m(...e) {
+	return (await import("./chunks/docx-LNMvqtvT.js")).createDocxDocument(...e);
+}
+//#endregion
+//#region src/extensions/ExportWord/fallback.ts
+var h = "__LANGEDITOR_WORD_EXPORT_FALLBACKS__";
+function g() {
+	let e = globalThis;
+	return e[h] ??= /* @__PURE__ */ new Map(), e[h];
+}
+function _(e) {
+	if (!e.id || !e.nodeType || typeof e.resolve != "function") throw Error("Invalid LangEditor Word export fallback definition");
+	let t = g();
+	return t.set(e.id, e), () => {
+		t.get(e.id) === e && t.delete(e.id);
+	};
+}
+function v() {
+	return Array.from(g().values());
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@vueuse+shared@14.4.0_vue@3.5.41_typescript@6.0.3_/node_modules/@vueuse/shared/dist/index.js
+function y(e, t) {
+	return o() ? (s(e, t), !0) : !1;
+}
+function b() {
+	let e = /* @__PURE__ */ new Set(), t = (t) => {
+		e.delete(t);
+	};
+	return {
+		on: (n) => {
+			e.add(n);
+			let r = () => t(n);
+			return y(r), { off: r };
+		},
+		off: t,
+		trigger: (...t) => Promise.all(Array.from(e).map((e) => e(...t))),
+		clear: () => {
+			e.clear();
+		}
+	};
+}
+var x = typeof window < "u" && typeof document < "u";
+typeof WorkerGlobalScope < "u" && globalThis instanceof WorkerGlobalScope;
+var S = (e, t) => Object.hasOwn(e, t), C = x ? window.document : void 0;
+x && window.navigator, x && window.location;
+function w(e) {
+	let t = u(e);
+	return t?.$el ?? t;
+}
+var T = {
+	multiple: !0,
+	accept: "*",
+	reset: !1,
+	directory: !1
+};
+function E(e) {
+	if (!e) return null;
+	if (e instanceof FileList) return e;
+	let t = new DataTransfer();
+	for (let n of e) t.items.add(n);
+	return t.files;
+}
+function D(e = {}) {
+	let { document: t = C } = e, n = l(E(e.initialFiles)), { on: r, trigger: i } = b(), { on: o, trigger: s } = b(), f = a(() => {
+		let r = w(e.input) ?? (t ? t.createElement("input") : void 0);
+		return r && (r.type = "file", r.onchange = (e) => {
+			let t = e.target;
+			n.value = t.files, i(n.value);
+		}, r.oncancel = () => {
+			s();
+		}), r;
+	}), p = () => {
+		n.value = null, f.value && f.value.value && (f.value.value = "", i(null));
+	}, m = (e) => {
+		let t = f.value;
+		t && (t.multiple = u(e.multiple), t.accept = u(e.accept), t.webkitdirectory = u(e.directory), S(e, "capture") && (t.capture = u(e.capture)));
+	};
+	return d(() => {
+		m(e);
+	}), {
+		files: c(n),
+		open: (t) => {
+			let n = f.value;
+			if (!n) return;
+			let r = {
+				...T,
+				...e,
+				...t
+			};
+			m(r), u(r.reset) && p(), n.click();
+		},
+		reset: p,
+		onCancel: o,
+		onChange: r
+	};
+}
+//#endregion
+//#region src/extensions/ImportWord/ImportWord.ts
+function O(e, t, n) {
+	let r = new Map(t.map((e, t) => [e.dataUrl, n[t]?.src]).filter((e) => !!e[1])), i = (e) => {
+		e.type === "image" && typeof e.attrs?.src == "string" && (e.attrs.src = r.get(e.attrs.src) || e.attrs.src);
+		for (let t of e.content ?? []) i(t);
+	};
+	i(e);
+}
+var k = t.create({
+	name: "importWord",
+	addOptions() {
+		return {
+			...this.parent?.(),
+			upload: void 0,
+			limit: 26214400,
+			button: ({ editor: t, t: n }) => ({
+				component: e,
+				componentProps: {
+					action: () => t.commands.toggleImportWord(),
+					disabled: !t.can().setHorizontalRule(),
+					icon: "FileUp",
+					tooltip: n("editor.importWord.tooltip")
+				}
+			})
+		};
+	},
+	addCommands() {
+		return { toggleImportWord: () => ({ editor: e }) => {
+			let { toast: t } = i(), { t: n } = r(), { open: a, onChange: o } = D({
+				accept: ".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+				reset: !0,
+				multiple: !1
+			});
+			return a(), o(async (r) => {
+				let i = r?.[0];
+				if (i) {
+					if (!i.name.toLowerCase().endsWith(".docx")) {
+						t({
+							title: n.value("editor.importWord.error"),
+							variant: "destructive"
+						});
+						return;
+					}
+					if (i.size > this.options.limit) {
+						t({
+							title: n.value("editor.importWord.fileTooLarge"),
+							variant: "destructive"
+						});
+						return;
+					}
+					try {
+						let { parseDocx: r } = await import("./chunks/docx-CTc58_gh.js"), a = await r(i), o = this.options.upload;
+						if (o && a.images.length) {
+							let e = await o(a.images.map((e) => e.file));
+							O(a.content, a.images, e);
+						}
+						e.commands.setContent(a.content, { emitUpdate: !0 }), e.view.dispatch(e.state.tr.setMeta("word-comments:import", a.comments)), a.warnings.length && console.warn("[LangEditor] DOCX import warnings:", a.warnings), t({ title: n.value("editor.importWord.success") });
+					} catch (e) {
+						console.error("Failed to import DOCX:", e), t({
+							title: n.value("editor.importWord.error"),
+							variant: "destructive"
+						});
+					}
+				}
+			}), !1;
+		} };
+	}
+});
+async function A(...e) {
+	return (await import("./chunks/docx-CTc58_gh.js")).parseDocx(...e);
+}
+//#endregion
+//#region src/manifest.ts
+var j = "@langeditor/plugin-docx", M = {
+	id: j,
+	version: "1.0.0",
+	coreRange: ">=1.1.0 <2.0.0",
+	requires: [],
+	conflicts: [],
+	provides: [
+		"serializer:docx",
+		"import:docx",
+		"export:docx"
+	],
+	enhances: ["document:word-comments", "document:word-pages"]
+};
+//#endregion
+//#region src/plugin.ts
+function N(e = {}) {
+	return [k.configure(e.importWord ?? {}), p.configure(e.exportWord ?? {})];
+}
+var P = n({
+	...M,
+	create: ({ options: e }) => ({ extensions: N(e.docx ?? {}) })
+});
+//#endregion
+export { j as DOCX_PLUGIN_ID, p as ExportWord, k as ImportWord, m as createDocxDocument, N as createDocxExtensions, M as docxManifest, v as getWordExportFallbacks, A as parseDocx, _ as registerWordExportFallback, P as unregisterDocxPlugin };

package/dist/manifest.d.ts

@@ -0,0 +1,10 @@
+export declare const DOCX_PLUGIN_ID = "@langeditor/plugin-docx";
+export declare const docxManifest: {
+    id: string;
+    version: string;
+    coreRange: string;
+    requires: string[];
+    conflicts: string[];
+    provides: string[];
+    enhances: string[];
+};

package/dist/plugin.d.ts

@@ -0,0 +1,9 @@
+import { ExportWordOptions } from './extensions/ExportWord';
+import { ImportWordOptions } from './extensions/ImportWord';
+export interface DocxPluginOptions {
+    importWord?: Partial<ImportWordOptions>;
+    exportWord?: Partial<ExportWordOptions>;
+}
+declare function createDocxExtensions(options?: DocxPluginOptions): (import('@tiptap/core').Extension<ExportWordOptions, any> | import('@tiptap/core').Extension<ImportWordOptions, any>)[];
+export declare const unregisterDocxPlugin: () => void;
+export { createDocxExtensions };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@langeditor/plugin-docx",
+  "version": "1.0.0",
+  "description": "DOCX import and export extensions for LangEditor.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": [
+    "./dist/index.es.js"
+  ],
+  "main": "./dist/index.es.js",
+  "module": "./dist/index.es.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "vue-tsc --noEmit -p tsconfig.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "PRD.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "@langeditor/core": ">=1.1.0 <2.0.0",
+    "@tiptap/core": "^3.30.2",
+    "vue": ">=3.5.0"
+  },
+  "dependencies": {
+    "@vueuse/core": "^14.4.0",
+    "docx": "^9.7.1",
+    "jszip": "^3.10.1",
+    "prosemirror-docx": "^0.6.1"
+  },
+  "devDependencies": {
+    "@langeditor/core": "workspace:*",
+    "@tailwindcss/vite": "^4.3.3",
+    "@vitejs/plugin-vue": "^6.0.8",
+    "tailwindcss": "^4.3.3",
+    "typescript": "~6.0.2",
+    "vite": "^8.2.2",
+    "vite-plugin-dts": "^5.0.3",
+    "vue": "^3.5.41",
+    "vue-tsc": "^3.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}