@lotics/docx 0.1.0

package/src/pm/commands_insert.test.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect } from "vitest";
+import { EditorState, TextSelection } from "prosemirror-state";
+import {
+  insertHorizontalRule,
+  insertLink,
+  insertPageBreak,
+  insertTable,
+  listEnter,
+} from "./commands";
+import { docxSchema } from "./schema";
+import {
+  EMPTY_PARAGRAPH_PROPERTIES,
+  type ParagraphProperties,
+} from "../model/properties";
+import { pmToDocx } from "./pm_to_docx";
+import { buildXml } from "@lotics/ooxml/xml";
+
+function emptyState() {
+  const doc = docxSchema.nodes.doc.create({}, [
+    docxSchema.nodes.paragraph.create(),
+  ]);
+  return EditorState.create({ doc, schema: docxSchema });
+}
+
+function applyAndRoundtrip(cmd: ReturnType<typeof insertTable>): string {
+  const state = emptyState();
+  let next = state;
+  const ok = cmd(state, (tr) => {
+    next = state.apply(tr);
+  });
+  expect(ok).toBe(true);
+  const docx = pmToDocx(next.doc, { parts: new Map(), documentAttrs: {} });
+  // Walk Block[] and produce a string for assertions.
+  const wrapped = {
+    "w:document": [{ "w:body": docx.body.children.map((b) => {
+      switch (b.kind) {
+        case "paragraph": {
+          const children: import("@lotics/ooxml/xml").XmlElement[] = [];
+          if (b.properties) children.push({ "w:pPr": [...b.properties] });
+          for (const inline of b.content) {
+            if (inline.kind === "run") {
+              const rChildren: import("@lotics/ooxml/xml").XmlElement[] = [];
+              if (inline.properties) rChildren.push({ "w:rPr": [...inline.properties] });
+              for (const c of inline.content) {
+                if (c.kind === "text") {
+                  rChildren.push({ "w:t": c.value === "" ? [] : [{ "#text": c.value }] });
+                } else {
+                  rChildren.push(c.xml);
+                }
+              }
+              children.push({ "w:r": rChildren });
+            } else {
+              children.push(inline.xml);
+            }
+          }
+          return { "w:p": children };
+        }
+        case "opaque_block":
+          return b.xml;
+        case "body_sect_pr":
+          return b.xml;
+      }
+    }) }],
+  } as import("@lotics/ooxml/xml").XmlElement;
+  return buildXml([wrapped]);
+}
+
+describe("insertHorizontalRule", () => {
+  it("emits a paragraph with w:pBdr bottom border (Word's HR shape)", () => {
+    const xml = applyAndRoundtrip(insertHorizontalRule());
+    expect(xml).toContain("<w:pBdr>");
+    expect(xml).toContain("<w:bottom");
+    expect(xml).toContain('w:val="single"');
+    expect(xml).not.toContain("HorizontalRule");
+  });
+});
+
+describe("insertTable", () => {
+  it("emits tblPr (TableGrid) and tblGrid with the requested column count", () => {
+    const xml = applyAndRoundtrip(insertTable(2, 3));
+    expect(xml).toContain("<w:tblPr>");
+    expect(xml).toContain('w:val="TableGrid"');
+    expect(xml).toContain("<w:tblGrid>");
+    const gridCols = xml.match(/<w:gridCol/g) ?? [];
+    expect(gridCols.length).toBe(3);
+    const rows = xml.match(/<w:tr>/g) ?? [];
+    expect(rows.length).toBe(2);
+  });
+});
+
+describe("insertLink", () => {
+  it("accepts internal anchors", () => {
+    const state = emptyState();
+    let dispatched = false;
+    const ok = insertLink("#bookmark1", "see chapter 1")(state, () => {
+      dispatched = true;
+    });
+    expect(ok).toBe(true);
+    expect(dispatched).toBe(true);
+  });
+
+  it("rejects external URLs", () => {
+    const state = emptyState();
+    let dispatched = false;
+    const ok = insertLink("https://example.com")(state, () => {
+      dispatched = true;
+    });
+    expect(ok).toBe(false);
+    expect(dispatched).toBe(false);
+  });
+
+  it("rejects empty anchor names", () => {
+    const state = emptyState();
+    const ok = insertLink("#")(state, () => {});
+    expect(ok).toBe(false);
+  });
+});
+
+describe("insertPageBreak", () => {
+  it("inserts a paragraph with pageBreakBefore=true", () => {
+    const state = emptyState();
+    let next: EditorState = state;
+    insertPageBreak()(state, (tr) => {
+      next = state.apply(tr);
+    });
+    let found = false;
+    next.doc.descendants((node) => {
+      if (node.type.name !== "paragraph") return true;
+      const props = node.attrs.properties as ParagraphProperties | null;
+      if (props?.pageBreakBefore) found = true;
+      return false;
+    });
+    expect(found).toBe(true);
+  });
+});
+
+describe("listEnter", () => {
+  function listDoc(text: string) {
+    const para = docxSchema.nodes.paragraph.create(
+      {
+        properties: {
+          ...EMPTY_PARAGRAPH_PROPERTIES,
+          numbering: { numId: 1, ilvl: 0 },
+        },
+        unknownProperties: [],
+        resolvedProperties: null,
+        resolvedBaseRun: null,
+        numberingLabel: null,
+      },
+      text.length === 0 ? undefined : [docxSchema.text(text)],
+    );
+    return docxSchema.nodes.doc.create({}, [para]);
+  }
+
+  it("clears numbering when the cursor is in an empty list item", () => {
+    const doc = listDoc("");
+    const state = EditorState.create({
+      doc,
+      schema: docxSchema,
+      selection: TextSelection.create(doc, 1),
+    });
+    let next = state;
+    const ok = listEnter()(state, (tr) => {
+      next = state.apply(tr);
+    });
+    expect(ok).toBe(true);
+    const props = next.doc.firstChild?.attrs.properties as
+      | ParagraphProperties
+      | null;
+    expect(props?.numbering).toBeNull();
+  });
+
+  it("yields control (returns false) when the list item is non-empty", () => {
+    const doc = listDoc("hello");
+    const state = EditorState.create({
+      doc,
+      schema: docxSchema,
+      selection: TextSelection.create(doc, 6),
+    });
+    const ok = listEnter()(state, () => {});
+    expect(ok).toBe(false);
+  });
+});

package/src/pm/docx_to_pm.test.ts

@@ -0,0 +1,330 @@
+import { describe, it, expect } from "vitest";
+import { parseXml, type XmlElement } from "@lotics/ooxml/xml";
+import {
+  createBlankDocx,
+  saveDocxToBuffer,
+  appendElement,
+} from "@lotics/ooxml/document";
+import { buildRun } from "@lotics/ooxml/builders";
+import { parseDocx } from "../parse/parser";
+import { docxToPm } from "./docx_to_pm";
+import type { DocxDocument } from "../model/types";
+
+const NS = `xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"`;
+
+function paragraph(children: XmlElement[]): XmlElement {
+  return { "w:p": children };
+}
+
+async function buildAndParse(
+  appendBlocks: (
+    doc: ReturnType<typeof createBlankDocx>,
+    paragraph: (children: XmlElement[]) => XmlElement,
+  ) => void,
+): Promise<DocxDocument> {
+  const doc = createBlankDocx();
+  appendBlocks(doc, paragraph);
+  const buffer = await saveDocxToBuffer(doc);
+  return parseDocx(new Uint8Array(buffer));
+}
+
+describe("docxToPm — basic structure", () => {
+  it("produces a doc node with at least one block", async () => {
+    const docx = await buildAndParse((doc, p) => {
+      appendElement(doc, p([buildRun("Hello")]));
+    });
+    const pm = docxToPm(docx);
+    expect(pm.type.name).toBe("doc");
+    expect(pm.childCount).toBeGreaterThan(0);
+  });
+
+  it("synthesizes a paragraph when body produces no PM nodes", () => {
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: { children: [] },
+    };
+    const pm = docxToPm(docx);
+    expect(pm.childCount).toBe(1);
+    expect(pm.firstChild!.type.name).toBe("paragraph");
+  });
+});
+
+describe("docxToPm — runs and marks", () => {
+  it("emits text without marks for plain runs", async () => {
+    const docx = await buildAndParse((doc, p) => {
+      appendElement(doc, p([buildRun("plain text")]));
+    });
+    const pm = docxToPm(docx);
+    const para = pm.firstChild!;
+    expect(para.type.name).toBe("paragraph");
+    expect(para.firstChild!.text).toBe("plain text");
+    expect(para.firstChild!.marks).toHaveLength(0);
+  });
+
+  it("emits bold mark for <w:b/> runs", async () => {
+    const docx = await buildAndParse((doc, p) => {
+      appendElement(doc, p([buildRun("bold", { bold: true })]));
+    });
+    const pm = docxToPm(docx);
+    const text = pm.firstChild!.firstChild!;
+    const names = text.marks.map((m) => m.type.name);
+    expect(names).toContain("bold");
+  });
+
+  it("preserves multiple marks on a single run (italic + bold)", async () => {
+    const docx = await buildAndParse((doc, p) => {
+      appendElement(
+        doc,
+        p([buildRun("both", { bold: true, italic: true })]),
+      );
+    });
+    const pm = docxToPm(docx);
+    const text = pm.firstChild!.firstChild!;
+    const names = text.marks.map((m) => m.type.name).sort();
+    expect(names).toEqual(["bold", "italic"]);
+  });
+
+  it("emits separate text segments for runs with different marks", async () => {
+    const docx = await buildAndParse((doc, p) => {
+      appendElement(
+        doc,
+        p([
+          buildRun("plain "),
+          buildRun("bold", { bold: true }),
+          buildRun(" plain again"),
+        ]),
+      );
+    });
+    const pm = docxToPm(docx);
+    const para = pm.firstChild!;
+    expect(para.childCount).toBe(3);
+    expect(para.child(0).text).toBe("plain ");
+    expect(para.child(0).marks).toHaveLength(0);
+    expect(para.child(1).text).toBe("bold");
+    expect(para.child(1).marks.map((m) => m.type.name)).toEqual(["bold"]);
+    expect(para.child(2).text).toBe(" plain again");
+  });
+});
+
+describe("docxToPm — paragraph properties", () => {
+  it("captures recognized pPr into paragraph node attrs", () => {
+    const pPr = parseXml(
+      `<w:pPr ${NS}><w:pStyle w:val="Heading1"/><w:jc w:val="center"/></w:pPr>`,
+    )[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          {
+            kind: "paragraph",
+            properties: pPr["w:pPr"] as XmlElement[],
+            content: [],
+          },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    const para = pm.firstChild!;
+    expect(para.attrs.properties.styleId).toBe("Heading1");
+    expect(para.attrs.properties.alignment).toBe("center");
+  });
+
+  it("partitions unrecognized pPr children into unknownProperties", () => {
+    const pPr = parseXml(
+      `<w:pPr ${NS}><w:pStyle w:val="Normal"/><w:divId w:val="123"/></w:pPr>`,
+    )[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          {
+            kind: "paragraph",
+            properties: pPr["w:pPr"] as XmlElement[],
+            content: [],
+          },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    const para = pm.firstChild!;
+    expect(para.attrs.properties.styleId).toBe("Normal");
+    expect(para.attrs.unknownProperties).toHaveLength(1);
+    expect(para.attrs.unknownProperties[0]).toMatchObject({
+      "w:divId": [],
+    });
+  });
+});
+
+describe("docxToPm — opaque pass-through", () => {
+  it("renders unknown body children as opaque_block", () => {
+    const sdtXml = parseXml(`<w:sdt ${NS}><w:sdtPr/></w:sdt>`)[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          { kind: "opaque_block", xml: sdtXml },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    expect(pm.firstChild!.type.name).toBe("opaque_block");
+    expect(pm.firstChild!.attrs.xml).toEqual(sdtXml);
+  });
+
+  it("converts <w:tbl> body children to a PM table node", () => {
+    const tblXml = parseXml(`<w:tbl ${NS}><w:tr><w:tc><w:p><w:r><w:t>x</w:t></w:r></w:p></w:tc></w:tr></w:tbl>`)[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          { kind: "opaque_block", xml: tblXml },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    expect(pm.firstChild!.type.name).toBe("table");
+    expect(pm.firstChild!.textContent).toContain("x");
+  });
+
+  it("renders unknown inline children as opaque_inline carrying marks", async () => {
+    const fldSimple = parseXml(
+      `<w:fldSimple ${NS} w:instr=" PAGE "><w:r><w:t>3</w:t></w:r></w:fldSimple>`,
+    )[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          {
+            kind: "paragraph",
+            properties: null,
+            content: [{ kind: "opaque_inline", xml: fldSimple }],
+          },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    const para = pm.firstChild!;
+    expect(para.firstChild!.type.name).toBe("opaque_inline");
+    expect(para.firstChild!.attrs.xml).toEqual(fldSimple);
+  });
+
+  it("renders unknown run children as opaque_inline", () => {
+    const sym = parseXml(
+      `<w:sym ${NS} w:font="Symbol" w:char="F0E0"/>`,
+    )[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          {
+            kind: "paragraph",
+            properties: null,
+            content: [
+              {
+                kind: "run",
+                properties: null,
+                content: [{ kind: "opaque_run_child", xml: sym }],
+              },
+            ],
+          },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    const para = pm.firstChild!;
+    expect(para.firstChild!.type.name).toBe("opaque_inline");
+    expect(para.firstChild!.attrs.xml).toEqual(sym);
+  });
+
+  it("converts <w:br/> to a hard_break inline node", () => {
+    const br = parseXml(`<w:br ${NS}/>`)[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          {
+            kind: "paragraph",
+            properties: null,
+            content: [
+              {
+                kind: "run",
+                properties: null,
+                content: [{ kind: "opaque_run_child", xml: br }],
+              },
+            ],
+          },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    expect(pm.firstChild!.firstChild!.type.name).toBe("hard_break");
+  });
+});
+
+describe("docxToPm — sections", () => {
+  it("emits a final section_break for body-level sectPr", async () => {
+    const docx = await buildAndParse((doc, p) => {
+      appendElement(doc, p([buildRun("body")]));
+    });
+    const pm = docxToPm(docx);
+    let breakCount = 0;
+    let finalCount = 0;
+    pm.descendants((node) => {
+      if (node.type.name === "section_break") {
+        breakCount += 1;
+        if (node.attrs.isFinal === true) finalCount += 1;
+      }
+      return false;
+    });
+    expect(breakCount).toBe(1);
+    expect(finalCount).toBe(1);
+  });
+
+  it("emits an inline section_break when sectPr is nested in a paragraph", () => {
+    const inlineSect = parseXml(
+      `<w:sectPr ${NS}><w:type w:val="continuous"/></w:sectPr>`,
+    )[0];
+    const finalSect = parseXml(
+      `<w:sectPr ${NS}><w:pgSz w:w="11906" w:h="16838"/></w:sectPr>`,
+    )[0];
+    const docx: DocxDocument = {
+      parts: new Map(),
+      documentAttrs: {},
+      body: {
+        children: [
+          { kind: "paragraph", properties: null, content: [] },
+          {
+            kind: "paragraph",
+            properties: [inlineSect],
+            content: [],
+          },
+          { kind: "paragraph", properties: null, content: [] },
+          { kind: "body_sect_pr", xml: finalSect },
+        ],
+      },
+    };
+    const pm = docxToPm(docx);
+    const breaks: { isFinal: boolean; type: string }[] = [];
+    pm.descendants((node) => {
+      if (node.type.name === "section_break") {
+        breaks.push({
+          isFinal: node.attrs.isFinal as boolean,
+          type: (node.attrs.properties as { type: string }).type,
+        });
+      }
+      return false;
+    });
+    expect(breaks).toEqual([
+      { isFinal: false, type: "continuous" },
+      { isFinal: true, type: "nextPage" },
+    ]);
+  });
+});