@portone/docx-editor 0.2.1 → 0.3.0

package/dist/docx/formatting/runProperties.js

@@ -0,0 +1,316 @@
+// src/docx/formatting/runProperties.ts
+import {
+  isHighlightName,
+  isUnderlineKind,
+  NO_FILL,
+  RUN_FORMAT_KEYS
+} from "../../model/format.js";
+import { elementXml, wAttrValue } from "../../ooxml/element.js";
+import { wName } from "../../ooxml/names.js";
+import { overridingAttrs, setAttr } from "../../ooxml/precedence.js";
+import {
+  attrsOf,
+  parseProps,
+  propsChild,
+  renderProps,
+  setChild
+} from "../../ooxml/props.js";
+import {
+  HALF_POINTS_PER_PT,
+  ST_HpsMeasure,
+  ST_SignedTwipsMeasure,
+  TWIPS_PER_PT
+} from "../../ooxml/simpleTypes.js";
+import {
+  childValue,
+  halfPointsToPt,
+  isOnElement,
+  normalizeHex,
+  shadingOf,
+  toHexColor,
+  twipsToPt,
+  wAttr
+} from "../../ooxml/units.js";
+import { childByLocalName } from "../../ooxml/xml.js";
+import { isEastAsianFontName } from "../../styles/fontStack.js";
+import { themeFontName } from "../theme.js";
+var DISPLAY_ONLY_RUN_KEYS = ["lang"];
+function isEditableRunKey(key) {
+  return !DISPLAY_ONLY_RUN_KEYS.some((display) => display === key);
+}
+var EDITABLE_RUN_KEYS = RUN_FORMAT_KEYS.filter(isEditableRunKey);
+function valXml(name, value) {
+  return elementXml(wName(name), value === null ? [] : [[wName("val"), value]]);
+}
+function shadingXml(fill) {
+  return elementXml(wName("shd"), [
+    [wName("val"), "clear"],
+    [wName("color"), "auto"],
+    [wName("fill"), fill]
+  ]);
+}
+function toggleState(rPr, name) {
+  const toggle2 = childByLocalName(rPr, name);
+  return toggle2 ? isOnElement(toggle2) : null;
+}
+function fontNamesOf(cssNames) {
+  if (!cssNames) return [];
+  return cssNames.split(",").map((name) => name.trim().replace(/^"|"$/g, "")).filter((name) => name.length > 0);
+}
+var FONT_SLOTS = ["ascii", "eastAsia", "hAnsi", "cs"];
+function slotFontName(rFonts, slot, themeFonts) {
+  const written2 = wAttr(rFonts, slot);
+  if (written2 !== null) return written2;
+  for (const attr of overridingAttrs("rFonts", slot)) {
+    const resolved = themeFontName(themeFonts, wAttr(rFonts, attr));
+    if (resolved !== null) return resolved;
+  }
+  return null;
+}
+function fontFamilyOf(rFonts, themeFonts) {
+  const names = FONT_SLOTS.map((slot) => slotFontName(rFonts, slot, themeFonts)).filter((name) => name !== null).filter((name) => name.length > 0 && !/["';\\]/.test(name));
+  const unique = Array.from(new Set(names));
+  return unique.length > 0 ? unique.map((name) => `"${name}"`).join(",") : null;
+}
+var LATIN_SLOTS = ["ascii", "hAnsi"];
+var EAST_ASIAN_SLOTS = [...LATIN_SLOTS, "eastAsia"];
+function fontSlots(name, hasComplexScript) {
+  const slots = isEastAsianFontName(name) ? EAST_ASIAN_SLOTS : LATIN_SLOTS;
+  return hasComplexScript ? [...slots, "cs"] : slots;
+}
+function fontName(value) {
+  const name = value.trim();
+  return name.length > 0 && !/["';<>&]/.test(name) ? name : null;
+}
+function rFontsXml(current, name) {
+  const props = current === null ? null : parseProps(current);
+  const attrs = props === null ? [] : attrsOf(props);
+  if (current !== null && props === null || attrs === null) return null;
+  const slots = fontSlots(name, wAttrValue(attrs, "cs") !== null);
+  const kept = slots.reduce(
+    (rest, slot) => setAttr(rest, "rFonts", slot, null),
+    attrs
+  );
+  return elementXml(wName("rFonts"), [
+    ...slots.map((slot) => [wName(slot), name]),
+    ...kept
+  ]);
+}
+function langOf(rPr) {
+  const lang = childByLocalName(rPr, "lang");
+  if (!lang) return null;
+  const eastAsia = wAttr(lang, "eastAsia");
+  if (eastAsia !== null && eastAsia.length > 0) return eastAsia;
+  const value = wAttr(lang, "val");
+  return value !== null && value.length > 0 ? value : null;
+}
+var VERTICAL_ALIGN_BY_VAL = {
+  superscript: "superscript",
+  subscript: "subscript"
+};
+function removed(children) {
+  return children.map((name) => [name, null]);
+}
+function toggle(key, name, ...twins) {
+  const children = [name, ...twins];
+  const isOn = (format) => format[key] === true;
+  return {
+    children,
+    read: (rPr) => toggleState(rPr, name) ?? void 0,
+    isOn,
+    matches: isOn,
+    write: () => children.map((child) => [child, valXml(child, null)]),
+    off: ({ inherited }) => isOn(inherited) ? children.map((child) => [child, valXml(child, "0")]) : removed(children)
+  };
+}
+var UNDERLINE = {
+  children: ["u"],
+  read: (rPr) => {
+    const kind = childValue(rPr, "u");
+    return isUnderlineKind(kind) || kind === "none" ? kind : void 0;
+  },
+  isOn: (format) => format.underline !== void 0 && format.underline !== "none",
+  matches: (format, kind) => format.underline === kind,
+  write: (kind) => [["u", valXml("u", kind)]],
+  off: ({ inherited }) => [
+    ["u", UNDERLINE.isOn(inherited) ? valXml("u", "none") : null]
+  ]
+};
+var FONT_SIZE = {
+  children: ["sz", "szCs"],
+  read: (rPr) => halfPointsToPt(ST_HpsMeasure.parse(childValue(rPr, "sz"))) ?? void 0,
+  isOn: (format) => format.fontSizePt !== void 0,
+  matches: (format, pt) => format.fontSizePt === pt,
+  write: (pt) => {
+    const half = ST_HpsMeasure.format(pt * HALF_POINTS_PER_PT);
+    return half === null ? null : [
+      ["sz", valXml("sz", half)],
+      ["szCs", valXml("szCs", half)]
+    ];
+  },
+  off: () => removed(FONT_SIZE.children)
+};
+var CHARACTER_SPACING = {
+  children: ["spacing"],
+  read: (rPr) => twipsToPt(ST_SignedTwipsMeasure.parse(childValue(rPr, "spacing"))) ?? void 0,
+  isOn: (format) => format.characterSpacingPt !== void 0,
+  matches: (format, pt) => format.characterSpacingPt === pt,
+  write: (pt) => {
+    const twips = ST_SignedTwipsMeasure.format(Math.round(pt * TWIPS_PER_PT));
+    return twips === null ? null : [["spacing", valXml("spacing", twips)]];
+  },
+  off: () => removed(CHARACTER_SPACING.children)
+};
+var FONT_FAMILY = {
+  children: ["rFonts"],
+  read: (rPr, themeFonts) => {
+    const rFonts = childByLocalName(rPr, "rFonts");
+    return rFonts ? fontFamilyOf(rFonts, themeFonts) ?? void 0 : void 0;
+  },
+  isOn: (format) => fontNamesOf(format.fontFamily).length > 0,
+  matches: (format, name) => {
+    const names = fontNamesOf(format.fontFamily);
+    return names.length === 1 && names[0] === fontName(name);
+  },
+  write: (name, { rPr }) => {
+    const clean = fontName(name);
+    if (clean === null) return null;
+    const xml = rFontsXml(
+      propsChild(rPr.children, "rFonts")?.xml ?? null,
+      clean
+    );
+    return xml === null ? null : [["rFonts", xml]];
+  },
+  off: () => removed(FONT_FAMILY.children)
+};
+var COLOR = {
+  children: ["color"],
+  read: (rPr) => toHexColor(childValue(rPr, "color")) ?? void 0,
+  isOn: (format) => format.color !== void 0,
+  // Colors differing only in capitalization are the same color
+  matches: (format, hex) => format.color !== void 0 && normalizeHex(format.color) === normalizeHex(hex),
+  write: (hex) => {
+    const value = normalizeHex(hex);
+    return value === null ? null : [["color", valXml("color", value)]];
+  },
+  off: ({ inherited }) => [
+    ["color", inherited.color === void 0 ? null : valXml("color", "auto")]
+  ]
+};
+var HIGHLIGHT = {
+  children: ["highlight"],
+  read: (rPr) => {
+    const name = childValue(rPr, "highlight");
+    return isHighlightName(name) ? name : void 0;
+  },
+  isOn: (format) => format.highlight !== void 0,
+  matches: (format, name) => format.highlight === name,
+  write: (name) => [["highlight", valXml("highlight", name)]],
+  off: ({ inherited }) => [
+    [
+      "highlight",
+      inherited.highlight === void 0 ? null : valXml("highlight", "none")
+    ]
+  ]
+};
+var BACKGROUND = {
+  children: ["highlight", "shd"],
+  read: (rPr) => shadingOf(rPr) ?? void 0,
+  isOn: (format) => format.highlight !== void 0 || format.background !== void 0 && format.background !== NO_FILL,
+  matches: (format, hex) => {
+    const fill = normalizeHex(hex);
+    return fill !== null && format.highlight === void 0 && format.background !== void 0 && normalizeHex(format.background) === fill;
+  },
+  write: (hex, context) => {
+    const fill = normalizeHex(hex);
+    return fill === null ? null : [["shd", shadingXml(fill)], ...HIGHLIGHT.off(context)];
+  },
+  off: (context) => {
+    const painted = context.inherited.background !== void 0 && context.inherited.background !== NO_FILL;
+    return [
+      ["shd", painted ? shadingXml("auto") : null],
+      ...HIGHLIGHT.off(context)
+    ];
+  }
+};
+var VERTICAL_ALIGN = {
+  children: ["vertAlign"],
+  read: (rPr) => VERTICAL_ALIGN_BY_VAL[childValue(rPr, "vertAlign") ?? ""],
+  isOn: (format) => format.verticalAlign !== void 0,
+  matches: (format, align) => format.verticalAlign === align,
+  write: (align) => [["vertAlign", valXml("vertAlign", align)]],
+  off: ({ inherited }) => [
+    [
+      "vertAlign",
+      inherited.verticalAlign === void 0 ? null : valXml("vertAlign", "baseline")
+    ]
+  ]
+};
+var LANG = {
+  children: ["lang"],
+  read: (rPr) => langOf(rPr) ?? void 0,
+  isOn: (format) => format.lang !== void 0,
+  matches: (format, tag) => format.lang === tag
+};
+var EDITABLE_RUN_PROPERTIES = {
+  bold: toggle("bold", "b", "bCs"),
+  italic: toggle("italic", "i", "iCs"),
+  strike: toggle("strike", "strike"),
+  doubleStrike: toggle("doubleStrike", "dstrike"),
+  smallCaps: toggle("smallCaps", "smallCaps"),
+  caps: toggle("caps", "caps"),
+  underline: UNDERLINE,
+  fontSizePt: FONT_SIZE,
+  characterSpacingPt: CHARACTER_SPACING,
+  fontFamily: FONT_FAMILY,
+  color: COLOR,
+  highlight: HIGHLIGHT,
+  background: BACKGROUND,
+  verticalAlign: VERTICAL_ALIGN
+};
+var DISPLAY_ONLY_RUN_PROPERTIES = { lang: LANG };
+var RUN_PROPERTIES = { ...EDITABLE_RUN_PROPERTIES, ...DISPLAY_ONLY_RUN_PROPERTIES };
+function runChildEdits(edit, context) {
+  const property = EDITABLE_RUN_PROPERTIES[edit.key];
+  return edit.value === null ? property.off(context) : property.write(edit.value, context);
+}
+function matchesRunEdit(format, edit) {
+  const property = RUN_PROPERTIES[edit.key];
+  const values = format ?? {};
+  return edit.value === null ? !property.isOn(values) : property.matches(values, edit.value);
+}
+function withChildEdits(rPr, edits) {
+  return edits.reduce((kept, [name, xml]) => setChild(kept, name, xml), rPr);
+}
+var EMPTY_RUN_PROPS = {
+  tag: wName("rPr"),
+  attrs: null,
+  children: []
+};
+function written(rPr, key, value) {
+  if (value === void 0) return rPr;
+  const edits = EDITABLE_RUN_PROPERTIES[key].write(value, {
+    rPr,
+    inherited: {}
+  });
+  return edits === null ? rPr : withChildEdits(rPr, edits);
+}
+function rPrOf(settings) {
+  const rPr = renderProps(
+    EDITABLE_RUN_KEYS.reduce(
+      (kept, key) => written(kept, key, settings[key]),
+      EMPTY_RUN_PROPS
+    )
+  );
+  return rPr === "" ? null : rPr;
+}
+export {
+  EDITABLE_RUN_KEYS,
+  EMPTY_RUN_PROPS,
+  RUN_PROPERTIES,
+  fontNamesOf,
+  matchesRunEdit,
+  rPrOf,
+  runChildEdits,
+  withChildEdits
+};

package/dist/docx/formatting/styles.js

@@ -4,9 +4,10 @@ import {
   toRunFormat,
   toTableFormat
 } from "../../model/format.js";
+import { parsePropsXml } from "../../ooxml/props.js";
+import { ST_OnOff } from "../../ooxml/simpleTypes.js";
 import { childValue, isOn, wAttr } from "../../ooxml/units.js";
 import { childByLocalName, elementChildren } from "../../ooxml/xml.js";
-import { parsePropsXml } from "../propsXml.js";
 import {
   layerCellMargins,
   layerInsideBorders,
@@ -84,8 +85,7 @@ function readStyles(styles, themeFonts = NO_THEME_FONTS) {
   return table;
 }
 function isDefaultStyle(el) {
-  const value = wAttr(el, "default");
-  return value === "1" || value === "true";
+  return ST_OnOff.parse(wAttr(el, "default")) === true;
 }
 function defaultStyleIdOf(styles, type) {
   let found = null;

package/dist/docx/formatting/tabStops.js

@@ -3,39 +3,24 @@ import { toParagraphFormat } from "../../model/format.js";
 import {
   layerTabStopDirectives
 } from "../../model/tabStops.js";
+import { ST_TabJc, ST_TabTlc } from "../../ooxml/simpleTypes.js";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var ALIGNMENTS = /* @__PURE__ */ new Set([
-  "start",
-  "center",
-  "end",
-  "decimal",
-  "num",
-  "bar",
-  "clear"
-]);
-var LEADERS = /* @__PURE__ */ new Set([
-  "none",
-  "dot",
-  "hyphen",
-  "underscore",
-  "heavy",
-  "middleDot"
-]);
 function toTabStopDirective(value) {
-  if (!isRecord(value) || typeof value.positionPt !== "number" || !Number.isFinite(value.positionPt) || typeof value.align !== "string" || !ALIGNMENTS.has(value.align)) {
+  if (!isRecord(value) || typeof value.positionPt !== "number" || !Number.isFinite(value.positionPt)) {
     return null;
   }
-  if (value.align === "clear") {
+  const align = typeof value.align === "string" ? ST_TabJc.parse(value.align) : null;
+  if (align === null) return null;
+  if (align === "clear") {
     return { positionPt: value.positionPt, align: "clear" };
   }
-  const align = value.align;
-  const leader = typeof value.leader === "string" && LEADERS.has(value.leader) ? value.leader : void 0;
+  const leader = typeof value.leader === "string" ? ST_TabTlc.parse(value.leader) : null;
   return {
     positionPt: value.positionPt,
     align,
-    ...leader === void 0 ? {} : { leader }
+    ...leader === null ? {} : { leader }
   };
 }
 function toParagraphFormatLayer(value) {

package/dist/docx/formatting.d.ts

@@ -1,4 +1,7 @@
+export * from "./formatting/attrs";
+export * from "./formatting/context";
 export * from "./formatting/direct";
-export * from "./formatting/effectiveParagraph";
+export * from "./formatting/resolve";
+export * from "./formatting/runProperties";
 export * from "./formatting/styles";
 export type { ParagraphFormatLayer } from "./formatting/tabStops";

package/dist/docx/formatting.js

@@ -1,4 +1,7 @@
 // src/docx/formatting.ts
+export * from "./formatting/attrs.js";
+export * from "./formatting/context.js";
 export * from "./formatting/direct.js";
-export * from "./formatting/effectiveParagraph.js";
+export * from "./formatting/resolve.js";
+export * from "./formatting/runProperties.js";
 export * from "./formatting/styles.js";

package/dist/docx/headersFooters.js

@@ -1,5 +1,5 @@
 // src/docx/headersFooters.ts
-import { ALIGN_BY_JC } from "../ooxml/units.js";
+import { ALIGN_BY_JC, isOnElement } from "../ooxml/units.js";
 import {
   attributeByLocalName,
   decodeUtf8,
@@ -8,6 +8,7 @@ import {
   R_NS,
   W_NS
 } from "../ooxml/xml.js";
+import { relatedPartPath } from "./packageParts.js";
 import { readRelationships, relsPathOf, resolveTarget } from "./relationships.js";
 var EMPTY_VARIANTS = {
   default: null,
@@ -21,11 +22,6 @@ var NO_HEADERS_FOOTERS = {
   evenAndOdd: false,
   pageNumberStart: 1
 };
-function isOn(el) {
-  if (!el) return false;
-  const value = attributeByLocalName(el, "val")?.toLowerCase();
-  return value !== "0" && value !== "false" && value !== "off";
-}
 function firstSectPrIn(root) {
   const namespaced = root.getElementsByTagNameNS(W_NS, "sectPr").item(0);
   if (namespaced) return namespaced;
@@ -131,15 +127,12 @@ function readContent(bytes) {
   };
 }
 function settingsEvenAndOdd(parts, mainPartPath) {
-  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
-    (entry) => entry.type === `${R_NS}/settings` && !entry.external
-  );
-  if (!relationship) return false;
-  const bytes = parts.get(resolveTarget(mainPartPath, relationship.target));
+  const path = relatedPartPath(parts, mainPartPath, `${R_NS}/settings`);
+  const bytes = path === null ? void 0 : parts.get(path);
   if (!bytes) return false;
   const root = parseXml(decodeUtf8(bytes).text).documentElement;
   const setting = root.getElementsByTagNameNS(W_NS, "evenAndOddHeaders").item(0);
-  return isOn(setting);
+  return isOnElement(setting);
 }
 function readVariants(parts, mainPartPath, sectPr, kind) {
   const relationships = new Map(
@@ -179,7 +172,7 @@ function readHeadersFooters(parts, mainPartPath, body) {
   return {
     headers: readVariants(parts, mainPartPath, sectPr, "header"),
     footers: readVariants(parts, mainPartPath, sectPr, "footer"),
-    firstPageDifferent: isOn(
+    firstPageDifferent: isOnElement(
       elementChildren(sectPr).find((child) => child.localName === "titlePg") ?? null
     ),
     evenAndOdd: settingsEvenAndOdd(parts, mainPartPath),

package/dist/docx/identities.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Settling, just before export, every name that may be held by one node only.
+ *
+ * An edit can leave one name standing in two places: splitting a paragraph inside a content
+ * control leaves that control in both halves, and dropping a copy of a paragraph carries the
+ * original's identifiers along with it. Each name a document must keep unique is one rule here,
+ * and the pass walks the blocks once in document order, so the first node to claim a name keeps it
+ * and every later claimant gives it up.
+ *
+ * A document nobody broke apart comes back node for node as it was, which is what keeps an
+ * unedited block going out as its original XML.
+ *
+ * The one walk answers two callers: `withUniqueIdentities` hands the writer the settled document
+ * and throws over a block that cannot yield, and `identityProblems` runs the same walk for
+ * `docx/invariants` and lists those blocks instead, so what the query reports and what the write
+ * refuses cannot come apart.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { type DocxExportErrorCode } from "../ooxml/errors";
+export interface IdentityRule {
+    readonly name: string;
+    /**
+     * The block to write in place of `block`, with every name it claims that `written` already holds
+     * given up, and the names it keeps added to `written`. Returns `block` itself when nothing
+     * changes. null means the block cannot yield and the export must refuse. A block's children are
+     * not visited here; the walker visits them after this call.
+     */
+    visit(block: PMNode, written: Set<string>): PMNode | null;
+}
+/**
+ * The block a node was opened from, which `docx/exportDocx` writes the original bytes back for.
+ * A second node claiming the same block is written from its own attrs instead, and a block that
+ * exists only as its original XML has nothing to be written from, so it cannot yield.
+ */
+export declare const sourceBlockRule: IdentityRule;
+/**
+ * A later paragraph carrying an identifier already written goes out without one, and without its
+ * `w14:textId` too, which may not stand without a `w14:paraId` beside it. The walker reaches the
+ * paragraphs inside a table, so the rule reads the one block it is handed.
+ */
+export declare const paragraphIdRule: IdentityRule;
+/**
+ * A content control cannot cross a paragraph, so splitting a paragraph in the middle of one leaves
+ * that same control standing in two, and dropping unmarked text into the middle of one breaks it
+ * in two within the paragraph. Each piece after the first opens as a copy with a `w:id` of its
+ * own (see `docx/sdt` for what a copy must not carry along).
+ */
+export declare const controlRule: IdentityRule;
+/**
+ * In the order they apply to one block: the source rule first, so that a second claimant of a
+ * block is already a rebuilt paragraph by the time the paragraph rule takes its identifier away.
+ */
+export declare const IDENTITY_RULES: readonly IdentityRule[];
+/** A block that cannot yield: what the export refuses it with, and where it stands in the document */
+export interface IdentityProblem {
+    readonly code: DocxExportErrorCode;
+    readonly message: string;
+    readonly pos: number;
+}
+/** The document with every later claimant of a name released, in document order */
+export declare function withUniqueIdentities(doc: PMNode, rules?: readonly IdentityRule[]): PMNode;
+/**
+ * Every block `withUniqueIdentities` would refuse over, in document order, each where it stands;
+ * empty when the pass would go through. The pass is run as the export runs it and its settled
+ * document is dropped, so a caller asking ahead of the write reads the same refusal it would throw.
+ */
+export declare function identityProblems(doc: PMNode, rules?: readonly IdentityRule[]): readonly IdentityProblem[];