@lotics/docx 0.1.0

package/src/pm/commands.ts

@@ -0,0 +1,697 @@
+import type { Command, EditorState, Transaction } from "prosemirror-state";
+import type { Node as PMNode } from "prosemirror-model";
+import {
+  EMPTY_PARAGRAPH_PROPERTIES,
+  EMPTY_RUN_PROPERTIES,
+  type ParagraphProperties,
+} from "../model/properties";
+import {
+  resolveParagraphProperties,
+  resolveRunProperties,
+} from "../model/style_resolution";
+import type { StyleTable } from "../model/style_table";
+import type {
+  Orientation,
+  PageMargins,
+  PageSize,
+  SectionProperties,
+} from "../model/sections";
+
+function paragraphRange(state: EditorState): { from: number; to: number } {
+  const { from, to } = state.selection;
+  const $from = state.doc.resolve(from);
+  const startBlock = $from.before($from.depth);
+  const $to = state.doc.resolve(to);
+  const endBlock = $to.after($to.depth);
+  return { from: startBlock, to: endBlock };
+}
+
+function forEachParagraphInRange(
+  state: EditorState,
+  visit: (node: PMNode, pos: number) => void,
+): void {
+  const { from, to } = paragraphRange(state);
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.type.name === "paragraph") {
+      visit(node, pos);
+      return false;
+    }
+    return true;
+  });
+}
+
+function patchParagraphProperties(
+  tr: Transaction,
+  pos: number,
+  node: PMNode,
+  patch: (current: ParagraphProperties) => ParagraphProperties,
+  styleTable: StyleTable | null,
+): void {
+  const current =
+    (node.attrs.properties as ParagraphProperties | null) ??
+    { ...EMPTY_PARAGRAPH_PROPERTIES };
+  const next = patch(current);
+  const resolvedProperties = styleTable
+    ? resolveParagraphProperties(styleTable, next)
+    : null;
+  const resolvedBaseRun = styleTable
+    ? resolveRunProperties(styleTable, next.styleId, { ...EMPTY_RUN_PROPERTIES })
+    : null;
+  tr.setNodeMarkup(pos, undefined, {
+    ...node.attrs,
+    properties: next,
+    resolvedProperties,
+    resolvedBaseRun,
+  });
+}
+
+export type CommandContext = {
+  styleTable?: StyleTable | null;
+};
+
+export function getActiveParagraphProperties(
+  state: EditorState,
+): ParagraphProperties | null {
+  const $from = state.doc.resolve(state.selection.from);
+  for (let depth = $from.depth; depth >= 0; depth--) {
+    const node = $from.node(depth);
+    if (node.type.name === "paragraph") {
+      return (node.attrs.properties as ParagraphProperties | null) ?? null;
+    }
+  }
+  return null;
+}
+
+export function setParagraphStyle(
+  styleId: string | null,
+  ctx: CommandContext = {},
+): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({ ...cur, styleId }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function applyHeading(
+  level: number,
+  ctx: CommandContext = {},
+): Command {
+  if (level < 1 || level > 6) {
+    return () => false;
+  }
+  return setParagraphStyle(`Heading${level}`, ctx);
+}
+
+export function clearParagraphStyle(ctx: CommandContext = {}): Command {
+  return setParagraphStyle(null, ctx);
+}
+
+export function setParagraphAlignment(
+  alignment: ParagraphProperties["alignment"],
+  ctx: CommandContext = {},
+): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({ ...cur, alignment }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function setParagraphNumbering(
+  numbering: { numId: number; ilvl: number } | null,
+  ctx: CommandContext = {},
+): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({ ...cur, numbering }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+const DEFAULT_BULLET_NUM_ID = 1;
+const DEFAULT_NUMBERED_NUM_ID = 2;
+
+export function toggleBulletList(ctx: CommandContext = {}): Command {
+  return toggleListImpl(DEFAULT_BULLET_NUM_ID, ctx);
+}
+
+export function toggleNumberedList(ctx: CommandContext = {}): Command {
+  return toggleListImpl(DEFAULT_NUMBERED_NUM_ID, ctx);
+}
+
+function toggleListImpl(numId: number, ctx: CommandContext): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    let allInList = true;
+    forEachParagraphInRange(state, (node) => {
+      const props = node.attrs.properties as ParagraphProperties | null;
+      const numbering = props?.numbering ?? null;
+      if (!numbering || numbering.numId !== numId) allInList = false;
+    });
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({
+          ...cur,
+          numbering: allInList ? null : { numId, ilvl: cur.numbering?.ilvl ?? 0 },
+        }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function increaseListIndent(ctx: CommandContext = {}): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      const props = node.attrs.properties as ParagraphProperties | null;
+      const numbering = props?.numbering;
+      if (!numbering) return;
+      const nextLevel = Math.min(numbering.ilvl + 1, 8);
+      if (nextLevel === numbering.ilvl) return;
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({
+          ...cur,
+          numbering: { numId: numbering.numId, ilvl: nextLevel },
+        }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// ── Spacing & indentation commands ───────────────────────────────────────
+
+const POINT_TO_TWIPS = 20;
+const TAB_TWIPS = 720; // 0.5"
+
+export function setLineSpacing(
+  multiplier: number,
+  ctx: CommandContext = {},
+): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({
+          ...cur,
+          spacing: {
+            before: cur.spacing?.before ?? null,
+            after: cur.spacing?.after ?? null,
+            line: Math.round(240 * multiplier),
+            lineRule: "auto",
+          },
+        }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function setParagraphSpacing(
+  before: number | null,
+  after: number | null,
+  ctx: CommandContext = {},
+): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({
+          ...cur,
+          spacing: {
+            before: before === null ? null : before * POINT_TO_TWIPS,
+            after: after === null ? null : after * POINT_TO_TWIPS,
+            line: cur.spacing?.line ?? null,
+            lineRule: cur.spacing?.lineRule ?? null,
+          },
+        }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+function applyIndentDelta(
+  delta: number,
+  ctx: CommandContext,
+): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => {
+          const baseLeft = cur.indent?.left ?? 0;
+          const nextLeft = Math.max(0, baseLeft + delta);
+          return {
+            ...cur,
+            indent: {
+              left: nextLeft,
+              right: cur.indent?.right ?? null,
+              firstLine: cur.indent?.firstLine ?? null,
+              hanging: cur.indent?.hanging ?? null,
+            },
+          };
+        },
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function increaseIndent(ctx: CommandContext = {}): Command {
+  return applyIndentDelta(TAB_TWIPS, ctx);
+}
+
+export function decreaseIndent(ctx: CommandContext = {}): Command {
+  return applyIndentDelta(-TAB_TWIPS, ctx);
+}
+
+export function decreaseListIndent(ctx: CommandContext = {}): Command {
+  return (state, dispatch) => {
+    let touched = false;
+    const tr = state.tr;
+    forEachParagraphInRange(state, (node, pos) => {
+      const props = node.attrs.properties as ParagraphProperties | null;
+      const numbering = props?.numbering;
+      if (!numbering) return;
+      if (numbering.ilvl === 0) return;
+      patchParagraphProperties(
+        tr,
+        pos,
+        node,
+        (cur) => ({
+          ...cur,
+          numbering: { numId: numbering.numId, ilvl: numbering.ilvl - 1 },
+        }),
+        ctx.styleTable ?? null,
+      );
+      touched = true;
+    });
+    if (!touched) return false;
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// ── Page layout commands ──────────────────────────────────────────────────
+
+function findSectionBreakAfter(
+  state: EditorState,
+  fromPos: number,
+): { node: PMNode; pos: number } | null {
+  let found: { node: PMNode; pos: number } | null = null;
+  state.doc.descendants((node, pos) => {
+    if (found) return false;
+    if (node.type.name !== "section_break") return true;
+    if (pos < fromPos) return false;
+    found = { node, pos };
+    return false;
+  });
+  if (found) return found;
+  state.doc.descendants((node, pos) => {
+    if (found) return false;
+    if (node.type.name === "section_break") {
+      found = { node, pos };
+    }
+    return false;
+  });
+  return found;
+}
+
+function patchSectionProperties(
+  tr: Transaction,
+  pos: number,
+  node: PMNode,
+  patch: (current: SectionProperties) => SectionProperties,
+): void {
+  const current = node.attrs.properties as SectionProperties;
+  const next = patch(current);
+  tr.setNodeMarkup(pos, undefined, { ...node.attrs, properties: next });
+}
+
+export function setPageSize(size: PageSize): Command {
+  return (state, dispatch) => {
+    const target = findSectionBreakAfter(state, state.selection.from);
+    if (!target) return false;
+    const tr = state.tr;
+    patchSectionProperties(tr, target.pos, target.node, (cur) => ({
+      ...cur,
+      pageSize: size,
+    }));
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function setPageMargins(margins: PageMargins): Command {
+  return (state, dispatch) => {
+    const target = findSectionBreakAfter(state, state.selection.from);
+    if (!target) return false;
+    const tr = state.tr;
+    patchSectionProperties(tr, target.pos, target.node, (cur) => ({
+      ...cur,
+      margins,
+    }));
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// ── List Enter handling ──────────────────────────────────────────────────
+
+/**
+ * Enter inside a list paragraph:
+ *  - if the paragraph is empty, exit the list (clear numbering)
+ *  - otherwise, split the paragraph keeping the same numbering
+ */
+export function listEnter(ctx: CommandContext = {}): Command {
+  return (state, dispatch) => {
+    const { selection } = state;
+    if (!selection.empty) return false;
+    const $from = selection.$from;
+    const node = $from.parent;
+    if (node.type.name !== "paragraph") return false;
+    const props = node.attrs.properties as ParagraphProperties | null;
+    const numbering = props?.numbering;
+    if (!numbering) return false;
+
+    if (node.content.size > 0) {
+      // Non-empty list item: yield to baseKeymap's Enter so the paragraph
+      // splits via the standard machinery (which copies attrs, including
+      // numbering, to the new paragraph).
+      return false;
+    }
+
+    // Empty list item: exit the list by clearing numbering on this paragraph.
+    const tr = state.tr;
+    patchParagraphProperties(
+      tr,
+      $from.before($from.depth),
+      node,
+      (cur) => ({ ...cur, numbering: null }),
+      ctx.styleTable ?? null,
+    );
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// ── Generic insertion commands ───────────────────────────────────────────
+
+export function insertHardBreak(): Command {
+  return (state, dispatch) => {
+    const node = state.schema.nodes.hard_break.create();
+    const tr = state.tr.replaceSelectionWith(node, false);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function insertPageBreak(): Command {
+  return (state, dispatch) => {
+    const para = state.schema.nodes.paragraph.create({
+      properties: { ...EMPTY_PARAGRAPH_PROPERTIES, pageBreakBefore: true },
+      unknownProperties: [],
+      resolvedProperties: null,
+      resolvedBaseRun: null,
+      numberingLabel: null,
+    });
+    const tr = state.tr.replaceSelectionWith(para, false);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// Default tblPr and tblGrid for fresh tables — matches what Word emits for
+// "Insert Table" with the TableGrid style (single 4px borders all around,
+// equal column widths summing to a 6" content area at 1440 dxa/inch).
+function buildDefaultTablePropertiesXml(): import("@lotics/ooxml/xml").XmlElement {
+  const border = (tag: string) => ({
+    [tag]: [],
+    ":@": {
+      "@_w:val": "single",
+      "@_w:sz": "4",
+      "@_w:space": "0",
+      "@_w:color": "auto",
+    },
+  });
+  return {
+    "w:tblPr": [
+      { "w:tblStyle": [], ":@": { "@_w:val": "TableGrid" } },
+      { "w:tblW": [], ":@": { "@_w:w": "0", "@_w:type": "auto" } },
+      {
+        "w:tblBorders": [
+          border("w:top"),
+          border("w:left"),
+          border("w:bottom"),
+          border("w:right"),
+          border("w:insideH"),
+          border("w:insideV"),
+        ],
+      },
+    ],
+  };
+}
+
+function buildDefaultTableGridXml(
+  cols: number,
+  totalDxa = 8640, // 6"
+): import("@lotics/ooxml/xml").XmlElement {
+  const colWidth = Math.floor(totalDxa / Math.max(cols, 1));
+  const gridCols = Array.from({ length: cols }, () => ({
+    "w:gridCol": [],
+    ":@": { "@_w:w": String(colWidth) },
+  }));
+  return { "w:tblGrid": gridCols };
+}
+
+export function insertTable(rows: number, cols: number): Command {
+  return (state, dispatch) => {
+    const { schema } = state;
+    const cellNodes = Array.from({ length: cols }, () =>
+      schema.nodes.table_cell.create({}, [schema.nodes.paragraph.create()]),
+    );
+    const rowNodes = Array.from({ length: rows }, () =>
+      schema.nodes.table_row.create({}, cellNodes),
+    );
+    const table = schema.nodes.table.create(
+      {
+        tableProperties: buildDefaultTablePropertiesXml(),
+        columnGrid: buildDefaultTableGridXml(cols),
+      },
+      rowNodes,
+    );
+    const tr = state.tr.replaceSelectionWith(table, false);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// Word's HR shape: a paragraph with <w:pBdr><w:bottom .../></w:pBdr>. The
+// pBdr element is held in unknownProperties so partitionParagraphProperties
+// preserves it through the docx ↔ PM round-trip without needing a typed
+// model field.
+const HR_PBDR_XML = {
+  "w:pBdr": [
+    {
+      "w:bottom": [],
+      ":@": {
+        "@_w:val": "single",
+        "@_w:sz": "6",
+        "@_w:space": "1",
+        "@_w:color": "auto",
+      },
+    },
+  ],
+};
+
+export function insertHorizontalRule(): Command {
+  return (state, dispatch) => {
+    const para = state.schema.nodes.paragraph.create({
+      properties: { ...EMPTY_PARAGRAPH_PROPERTIES },
+      unknownProperties: [HR_PBDR_XML],
+      resolvedProperties: null,
+      resolvedBaseRun: null,
+      numberingLabel: null,
+    });
+    const tr = state.tr.replaceSelectionWith(para, false);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+/**
+ * Insert a link into the doc.
+ *
+ * Currently only **internal anchors** (`#bookmarkName`) round-trip cleanly —
+ * external URLs require allocating a relationship in the document's rels
+ * map, which there is no plumbing for at the insertion site yet. Passing an
+ * external URL is rejected with `false` so the caller can show a useful
+ * error rather than silently producing invalid OOXML.
+ */
+export function insertLink(href: string, text?: string): Command {
+  return (state, dispatch) => {
+    const linkMark = state.schema.marks.link;
+    if (!linkMark) return false;
+    if (!href.startsWith("#")) {
+      // External hyperlinks need a relationship id allocator. Refuse rather
+      // than emitting <w:hyperlink w:anchor="https://..."> which is invalid.
+      return false;
+    }
+    const anchor = href.slice(1);
+    if (anchor.length === 0) return false;
+    const mark = linkMark.create({ relationshipId: null, anchor });
+    const display = text ?? href;
+    const node = state.schema.text(display, [mark]);
+    const tr = state.tr.replaceSelectionWith(node, false);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+// ── Template insertion commands ──────────────────────────────────────────
+
+function insertTextAtSelection(text: string): Command {
+  return (state, dispatch) => {
+    const tr = state.tr.replaceSelectionWith(state.schema.text(text), false);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function insertVariable(name: string): Command {
+  if (!name) return () => false;
+  return insertTextAtSelection(`{{${name}}}`);
+}
+
+export function insertLoopVariable(loopVar: string, field: string): Command {
+  if (!loopVar || !field) return () => false;
+  return insertTextAtSelection(`{{$${loopVar}.${field}}}`);
+}
+
+export function wrapSelectionInLoop(loopVar: string, arrayName: string): Command {
+  if (!loopVar || !arrayName) return () => false;
+  return (state, dispatch) => {
+    const { from, to } = state.selection;
+    if (from === to) return false;
+    const tr = state.tr;
+    const startText = state.schema.text(`{{FOR ${loopVar} IN ${arrayName}}}`);
+    const endText = state.schema.text(`{{END-FOR ${arrayName}}}`);
+    tr.insert(to, endText);
+    tr.insert(from, startText);
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function wrapSelectionInConditional(condition: string): Command {
+  if (!condition) return () => false;
+  return (state, dispatch) => {
+    const { from, to } = state.selection;
+    if (from === to) return false;
+    const tr = state.tr;
+    tr.insert(to, state.schema.text(`{{END-IF ${condition}}}`));
+    tr.insert(from, state.schema.text(`{{IF ${condition}}}`));
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}
+
+export function setPageOrientation(orientation: Orientation): Command {
+  return (state, dispatch) => {
+    const target = findSectionBreakAfter(state, state.selection.from);
+    if (!target) return false;
+    const tr = state.tr;
+    patchSectionProperties(tr, target.pos, target.node, (cur) => {
+      if (cur.pageSize.orientation === orientation) return cur;
+      return {
+        ...cur,
+        pageSize: {
+          width: cur.pageSize.height,
+          height: cur.pageSize.width,
+          orientation,
+        },
+      };
+    });
+    if (dispatch) dispatch(tr);
+    return true;
+  };
+}