@lotics/docx 0.1.0

package/src/model/default_styles.ts

@@ -0,0 +1,201 @@
+import {
+  EMPTY_PARAGRAPH_PROPERTIES,
+  EMPTY_RUN_PROPERTIES,
+  type ParagraphProperties,
+  type RunProperties,
+} from "./properties";
+import type { Style, StyleTable } from "./style_table";
+
+const PT_TO_HALF_POINTS = 2;
+const PT_TO_TWIPS = 20;
+
+function paraProps(
+  partial: Partial<ParagraphProperties> = {},
+): ParagraphProperties {
+  return { ...EMPTY_PARAGRAPH_PROPERTIES, ...partial };
+}
+
+function runProps(
+  partial: Partial<RunProperties> = {},
+): RunProperties {
+  return { ...EMPTY_RUN_PROPERTIES, ...partial };
+}
+
+function spacing(beforePt: number, afterPt: number, lineMult = 1.15) {
+  return {
+    before: beforePt * PT_TO_TWIPS,
+    after: afterPt * PT_TO_TWIPS,
+    line: Math.round(240 * lineMult),
+    lineRule: "auto" as const,
+  };
+}
+
+function defaultStyle(
+  id: string,
+  name: string,
+  paragraphProperties: ParagraphProperties | null,
+  runProperties: RunProperties | null,
+  basedOn: string | null = null,
+): [string, Style] {
+  return [
+    id,
+    {
+      id,
+      name,
+      type: "paragraph",
+      basedOn,
+      linkedStyleId: null,
+      paragraphProperties,
+      runProperties,
+      isDefault: false,
+    },
+  ];
+}
+
+function buildDefaultStyles(): ReadonlyMap<string, Style> {
+  const out = new Map<string, Style>();
+  out.set(...defaultStyle(
+    "Normal",
+    "Normal",
+    paraProps({ spacing: spacing(0, 8, 1.15) }),
+    runProps({ size: 11 * PT_TO_HALF_POINTS, color: "1F1F1F", fontAscii: "Calibri" }),
+  ));
+  out.set(...defaultStyle(
+    "Title",
+    "Title",
+    paraProps({ spacing: spacing(0, 4, 1.0) }),
+    runProps({
+      size: 28 * PT_TO_HALF_POINTS,
+      color: "1F1F1F",
+      bold: false,
+      fontAscii: "Calibri Light",
+    }),
+    "Normal",
+  ));
+  out.set(...defaultStyle(
+    "Subtitle",
+    "Subtitle",
+    paraProps({ spacing: spacing(0, 8, 1.15) }),
+    runProps({
+      size: 14 * PT_TO_HALF_POINTS,
+      color: "595959",
+      italic: true,
+      fontAscii: "Calibri",
+    }),
+    "Normal",
+  ));
+  out.set(...defaultStyle(
+    "Heading1",
+    "Heading 1",
+    paraProps({ spacing: spacing(12, 0, 1.15), keepNext: true, keepLines: true, outlineLevel: 0 }),
+    runProps({
+      size: 16 * PT_TO_HALF_POINTS,
+      color: "2E74B5",
+      bold: true,
+      fontAscii: "Calibri Light",
+    }),
+    "Normal",
+  ));
+  out.set(...defaultStyle(
+    "Heading2",
+    "Heading 2",
+    paraProps({ spacing: spacing(8, 0, 1.15), keepNext: true, keepLines: true, outlineLevel: 1 }),
+    runProps({
+      size: 13 * PT_TO_HALF_POINTS,
+      color: "2E74B5",
+      bold: true,
+      fontAscii: "Calibri Light",
+    }),
+    "Normal",
+  ));
+  out.set(...defaultStyle(
+    "Heading3",
+    "Heading 3",
+    paraProps({ spacing: spacing(8, 0, 1.15), keepNext: true, keepLines: true, outlineLevel: 2 }),
+    runProps({
+      size: 12 * PT_TO_HALF_POINTS,
+      color: "1F4E79",
+      bold: true,
+      fontAscii: "Calibri Light",
+    }),
+    "Normal",
+  ));
+  for (let level = 4; level <= 6; level++) {
+    out.set(...defaultStyle(
+      `Heading${level}`,
+      `Heading ${level}`,
+      paraProps({ spacing: spacing(6, 0, 1.15), keepNext: true, keepLines: true, outlineLevel: level - 1 }),
+      runProps({
+        size: 11 * PT_TO_HALF_POINTS,
+        color: "2E74B5",
+        bold: true,
+        italic: true,
+        fontAscii: "Calibri",
+      }),
+      "Normal",
+    ));
+  }
+  out.set(...defaultStyle(
+    "Quote",
+    "Quote",
+    paraProps({ spacing: spacing(8, 8, 1.15), indent: { left: 360, right: 360, firstLine: null, hanging: null } }),
+    runProps({
+      size: 11 * PT_TO_HALF_POINTS,
+      color: "404040",
+      italic: true,
+      fontAscii: "Calibri",
+    }),
+    "Normal",
+  ));
+  out.set(...defaultStyle(
+    "Code",
+    "Code",
+    paraProps({ spacing: spacing(0, 0, 1.0) }),
+    runProps({
+      size: 10 * PT_TO_HALF_POINTS,
+      color: "1F1F1F",
+      fontAscii: "Consolas",
+    }),
+    "Normal",
+  ));
+  return out;
+}
+
+const DEFAULT_STYLES = buildDefaultStyles();
+
+export function buildDefaultStyleTable(): StyleTable {
+  return {
+    paragraphDefaults: paraProps({ spacing: spacing(0, 8, 1.15) }),
+    runDefaults: runProps({
+      size: 11 * PT_TO_HALF_POINTS,
+      color: "1F1F1F",
+      fontAscii: "Calibri",
+    }),
+    styles: DEFAULT_STYLES,
+    defaultParagraphStyleId: "Normal",
+    defaultCharacterStyleId: null,
+  };
+}
+
+/**
+ * Merge a parsed StyleTable with the built-in defaults. Parsed styles win;
+ * defaults fill in any missing IDs (e.g. when the docx omits styles.xml or
+ * doesn't define common headings).
+ */
+export function withDefaultStyles(parsed: StyleTable | null): StyleTable {
+  const defaults = buildDefaultStyleTable();
+  if (!parsed) return defaults;
+  const merged = new Map(defaults.styles);
+  for (const [id, style] of parsed.styles) {
+    merged.set(id, style);
+  }
+  return {
+    paragraphDefaults: parsed.paragraphDefaults ?? defaults.paragraphDefaults,
+    runDefaults: parsed.runDefaults ?? defaults.runDefaults,
+    styles: merged,
+    defaultParagraphStyleId:
+      parsed.defaultParagraphStyleId ?? defaults.defaultParagraphStyleId,
+    defaultCharacterStyleId:
+      parsed.defaultCharacterStyleId ?? defaults.defaultCharacterStyleId,
+  };
+}

package/src/model/numbering_table.ts

@@ -0,0 +1,52 @@
+import type { ParagraphProperties, RunProperties } from "./properties";
+
+export type NumberFormat =
+  | "decimal"
+  | "decimalZero"
+  | "lowerLetter"
+  | "upperLetter"
+  | "lowerRoman"
+  | "upperRoman"
+  | "bullet"
+  | "none";
+
+export type Justification = "left" | "center" | "right";
+
+export type NumberingLevel = {
+  ilvl: number;
+  start: number;
+  numFmt: NumberFormat;
+  lvlText: string;
+  lvlJc: Justification;
+  lvlRestart: number | null;
+  paragraphProperties: ParagraphProperties | null;
+  runProperties: RunProperties | null;
+  suff: "tab" | "space" | "nothing";
+};
+
+export type AbstractNum = {
+  abstractNumId: number;
+  levels: ReadonlyMap<number, NumberingLevel>;
+};
+
+export type LvlOverride = {
+  ilvl: number;
+  startOverride: number | null;
+  level: NumberingLevel | null;
+};
+
+export type Num = {
+  numId: number;
+  abstractNumId: number;
+  overrides: ReadonlyMap<number, LvlOverride>;
+};
+
+export type NumberingTable = {
+  abstractNums: ReadonlyMap<number, AbstractNum>;
+  nums: ReadonlyMap<number, Num>;
+};
+
+export const EMPTY_NUMBERING_TABLE: NumberingTable = {
+  abstractNums: new Map(),
+  nums: new Map(),
+};

package/src/model/properties.ts

@@ -0,0 +1,328 @@
+import {
+  getAttr,
+  getChildren,
+  getTagName,
+  type XmlElement,
+} from "@lotics/ooxml/xml";
+
+export type Alignment =
+  | "left"
+  | "center"
+  | "right"
+  | "both"
+  | "start"
+  | "end"
+  | "distribute";
+
+export type LineRule = "auto" | "exact" | "atLeast";
+
+export type UnderlineStyle =
+  | "single"
+  | "double"
+  | "thick"
+  | "dotted"
+  | "dash"
+  | "dashLong"
+  | "dotDash"
+  | "dotDotDash"
+  | "wave"
+  | "wavyDouble"
+  | "wavyHeavy"
+  | "words"
+  | "none";
+
+export type VerticalAlignRun = "baseline" | "superscript" | "subscript";
+
+export type ParagraphProperties = {
+  styleId: string | null;
+  alignment: Alignment | null;
+  indent: {
+    left: number | null;
+    right: number | null;
+    firstLine: number | null;
+    hanging: number | null;
+  } | null;
+  spacing: {
+    before: number | null;
+    after: number | null;
+    line: number | null;
+    lineRule: LineRule | null;
+  } | null;
+  numbering: { numId: number; ilvl: number } | null;
+  pageBreakBefore: boolean | null;
+  keepLines: boolean | null;
+  keepNext: boolean | null;
+  widowControl: boolean | null;
+  outlineLevel: number | null;
+};
+
+export type RunProperties = {
+  styleId: string | null;
+  bold: boolean | null;
+  italic: boolean | null;
+  underline: UnderlineStyle | null;
+  strike: boolean | null;
+  doubleStrike: boolean | null;
+  caps: boolean | null;
+  smallCaps: boolean | null;
+  color: string | null;
+  themeColor: string | null;
+  themeTint: string | null;
+  themeShade: string | null;
+  highlight: string | null;
+  size: number | null;
+  fontAscii: string | null;
+  fontHAnsi: string | null;
+  fontEastAsia: string | null;
+  fontComplexScript: string | null;
+  vertAlign: VerticalAlignRun | null;
+};
+
+export const EMPTY_PARAGRAPH_PROPERTIES: ParagraphProperties = {
+  styleId: null,
+  alignment: null,
+  indent: null,
+  spacing: null,
+  numbering: null,
+  pageBreakBefore: null,
+  keepLines: null,
+  keepNext: null,
+  widowControl: null,
+  outlineLevel: null,
+};
+
+export const EMPTY_RUN_PROPERTIES: RunProperties = {
+  styleId: null,
+  bold: null,
+  italic: null,
+  underline: null,
+  strike: null,
+  doubleStrike: null,
+  caps: null,
+  smallCaps: null,
+  color: null,
+  themeColor: null,
+  themeTint: null,
+  themeShade: null,
+  highlight: null,
+  size: null,
+  fontAscii: null,
+  fontHAnsi: null,
+  fontEastAsia: null,
+  fontComplexScript: null,
+  vertAlign: null,
+};
+
+function readToggle(el: XmlElement): boolean {
+  const val = getAttr(el, "w:val");
+  if (val === undefined) return true;
+  if (val === "0" || val === "false") return false;
+  return true;
+}
+
+function parseIntOrNull(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const n = Number.parseInt(value, 10);
+  return Number.isFinite(n) ? n : null;
+}
+
+function isAlignment(value: string): value is Alignment {
+  return (
+    value === "left" ||
+    value === "center" ||
+    value === "right" ||
+    value === "both" ||
+    value === "start" ||
+    value === "end" ||
+    value === "distribute"
+  );
+}
+
+function isLineRule(value: string): value is LineRule {
+  return value === "auto" || value === "exact" || value === "atLeast";
+}
+
+function isUnderlineStyle(value: string): value is UnderlineStyle {
+  return (
+    value === "single" ||
+    value === "double" ||
+    value === "thick" ||
+    value === "dotted" ||
+    value === "dash" ||
+    value === "dashLong" ||
+    value === "dotDash" ||
+    value === "dotDotDash" ||
+    value === "wave" ||
+    value === "wavyDouble" ||
+    value === "wavyHeavy" ||
+    value === "words" ||
+    value === "none"
+  );
+}
+
+function isVertAlignRun(value: string): value is VerticalAlignRun {
+  return value === "baseline" || value === "superscript" || value === "subscript";
+}
+
+export function extractParagraphProperties(
+  pPrChildren: readonly XmlElement[],
+): ParagraphProperties {
+  const out: ParagraphProperties = { ...EMPTY_PARAGRAPH_PROPERTIES };
+
+  for (const el of pPrChildren) {
+    const tag = getTagName(el);
+    switch (tag) {
+      case "w:pStyle": {
+        const v = getAttr(el, "w:val");
+        if (v) out.styleId = v;
+        break;
+      }
+      case "w:jc": {
+        const v = getAttr(el, "w:val");
+        if (v && isAlignment(v)) out.alignment = v;
+        break;
+      }
+      case "w:ind": {
+        const left = parseIntOrNull(getAttr(el, "w:left") ?? getAttr(el, "w:start"));
+        const right = parseIntOrNull(getAttr(el, "w:right") ?? getAttr(el, "w:end"));
+        const firstLine = parseIntOrNull(getAttr(el, "w:firstLine"));
+        const hanging = parseIntOrNull(getAttr(el, "w:hanging"));
+        if (left !== null || right !== null || firstLine !== null || hanging !== null) {
+          out.indent = { left, right, firstLine, hanging };
+        }
+        break;
+      }
+      case "w:spacing": {
+        const before = parseIntOrNull(getAttr(el, "w:before"));
+        const after = parseIntOrNull(getAttr(el, "w:after"));
+        const line = parseIntOrNull(getAttr(el, "w:line"));
+        const lineRuleStr = getAttr(el, "w:lineRule");
+        const lineRule =
+          lineRuleStr && isLineRule(lineRuleStr) ? lineRuleStr : null;
+        if (
+          before !== null ||
+          after !== null ||
+          line !== null ||
+          lineRule !== null
+        ) {
+          out.spacing = { before, after, line, lineRule };
+        }
+        break;
+      }
+      case "w:numPr": {
+        let numId: number | null = null;
+        let ilvl = 0;
+        for (const child of getChildren(el)) {
+          const childTag = getTagName(child);
+          if (childTag === "w:numId") {
+            numId = parseIntOrNull(getAttr(child, "w:val"));
+          } else if (childTag === "w:ilvl") {
+            const lvl = parseIntOrNull(getAttr(child, "w:val"));
+            if (lvl !== null) ilvl = lvl;
+          }
+        }
+        if (numId !== null) out.numbering = { numId, ilvl };
+        break;
+      }
+      case "w:pageBreakBefore":
+        out.pageBreakBefore = readToggle(el);
+        break;
+      case "w:keepLines":
+        out.keepLines = readToggle(el);
+        break;
+      case "w:keepNext":
+        out.keepNext = readToggle(el);
+        break;
+      case "w:widowControl":
+        out.widowControl = readToggle(el);
+        break;
+      case "w:outlineLvl": {
+        const v = parseIntOrNull(getAttr(el, "w:val"));
+        if (v !== null) out.outlineLevel = v;
+        break;
+      }
+    }
+  }
+
+  return out;
+}
+
+export function extractRunProperties(
+  rPrChildren: readonly XmlElement[],
+): RunProperties {
+  const out: RunProperties = { ...EMPTY_RUN_PROPERTIES };
+
+  for (const el of rPrChildren) {
+    const tag = getTagName(el);
+    switch (tag) {
+      case "w:rStyle": {
+        const v = getAttr(el, "w:val");
+        if (v) out.styleId = v;
+        break;
+      }
+      case "w:b":
+        out.bold = readToggle(el);
+        break;
+      case "w:i":
+        out.italic = readToggle(el);
+        break;
+      case "w:u": {
+        const v = getAttr(el, "w:val");
+        if (v && isUnderlineStyle(v)) out.underline = v;
+        else if (v === undefined) out.underline = "single";
+        break;
+      }
+      case "w:strike":
+        out.strike = readToggle(el);
+        break;
+      case "w:dstrike":
+        out.doubleStrike = readToggle(el);
+        break;
+      case "w:caps":
+        out.caps = readToggle(el);
+        break;
+      case "w:smallCaps":
+        out.smallCaps = readToggle(el);
+        break;
+      case "w:color": {
+        const v = getAttr(el, "w:val");
+        if (v && v !== "auto") out.color = v;
+        const themeColor = getAttr(el, "w:themeColor");
+        if (themeColor) out.themeColor = themeColor;
+        const themeTint = getAttr(el, "w:themeTint");
+        if (themeTint) out.themeTint = themeTint;
+        const themeShade = getAttr(el, "w:themeShade");
+        if (themeShade) out.themeShade = themeShade;
+        break;
+      }
+      case "w:highlight": {
+        const v = getAttr(el, "w:val");
+        if (v) out.highlight = v;
+        break;
+      }
+      case "w:sz": {
+        const v = parseIntOrNull(getAttr(el, "w:val"));
+        if (v !== null) out.size = v;
+        break;
+      }
+      case "w:rFonts": {
+        const ascii = getAttr(el, "w:ascii");
+        const hAnsi = getAttr(el, "w:hAnsi");
+        const eastAsia = getAttr(el, "w:eastAsia");
+        const cs = getAttr(el, "w:cs");
+        if (ascii) out.fontAscii = ascii;
+        if (hAnsi) out.fontHAnsi = hAnsi;
+        if (eastAsia) out.fontEastAsia = eastAsia;
+        if (cs) out.fontComplexScript = cs;
+        break;
+      }
+      case "w:vertAlign": {
+        const v = getAttr(el, "w:val");
+        if (v && isVertAlignRun(v)) out.vertAlign = v;
+        break;
+      }
+    }
+  }
+
+  return out;
+}

package/src/model/sections.ts

@@ -0,0 +1,94 @@
+export type Orientation = "portrait" | "landscape";
+
+export type PageSize = {
+  width: number;
+  height: number;
+  orientation: Orientation;
+};
+
+export type PageMargins = {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+  header: number;
+  footer: number;
+  gutter: number;
+};
+
+export type Column = {
+  width: number | null;
+  space: number | null;
+};
+
+export type Columns = {
+  count: number;
+  space: number | null;
+  equalWidth: boolean;
+  separator: boolean;
+  columns: readonly Column[];
+};
+
+export type SectionType =
+  | "continuous"
+  | "evenPage"
+  | "nextColumn"
+  | "nextPage"
+  | "oddPage";
+
+export type HeaderFooterType = "default" | "first" | "even";
+
+export type HeaderFooterRef = {
+  type: HeaderFooterType;
+  relationshipId: string;
+};
+
+export type SectionProperties = {
+  type: SectionType;
+  pageSize: PageSize;
+  margins: PageMargins;
+  columns: Columns;
+  titlePage: boolean;
+  headerRefs: readonly HeaderFooterRef[];
+  footerRefs: readonly HeaderFooterRef[];
+};
+
+export type Section = {
+  properties: SectionProperties;
+  blockStartIndex: number;
+  blockEndIndex: number;
+};
+
+export const DEFAULT_PAGE_SIZE: PageSize = {
+  width: 12240,
+  height: 15840,
+  orientation: "portrait",
+};
+
+export const DEFAULT_PAGE_MARGINS: PageMargins = {
+  top: 1440,
+  right: 1440,
+  bottom: 1440,
+  left: 1440,
+  header: 720,
+  footer: 720,
+  gutter: 0,
+};
+
+export const DEFAULT_COLUMNS: Columns = {
+  count: 1,
+  space: null,
+  equalWidth: true,
+  separator: false,
+  columns: [],
+};
+
+export const DEFAULT_SECTION_PROPERTIES: SectionProperties = {
+  type: "nextPage",
+  pageSize: DEFAULT_PAGE_SIZE,
+  margins: DEFAULT_PAGE_MARGINS,
+  columns: DEFAULT_COLUMNS,
+  titlePage: false,
+  headerRefs: [],
+  footerRefs: [],
+};