@lotics/docx 0.1.0

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@lotics/docx",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsgo --noEmit",
+    "lint": "oxlint",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@lotics/ooxml": "^0.1.0",
+    "fast-xml-parser": "^4.4.1",
+    "jszip": "^3.10.1",
+    "prosemirror-commands": "^1.7.1",
+    "prosemirror-dropcursor": "^1.8.2",
+    "prosemirror-gapcursor": "^1.4.1",
+    "prosemirror-history": "^1.5.0",
+    "prosemirror-inputrules": "^1.5.1",
+    "prosemirror-keymap": "^1.2.3",
+    "prosemirror-model": "^1.25.4",
+    "prosemirror-search": "^1.1.0",
+    "prosemirror-state": "^1.4.4",
+    "prosemirror-tables": "^1.8.5",
+    "prosemirror-view": "^1.41.8"
+  },
+  "devDependencies": {
+    "happy-dom": "^20.9.0",
+    "vitest": "^4.1.7"
+  }
+}

package/src/fonts/bundled.ts

@@ -0,0 +1,123 @@
+import type { BundledFont } from "./types";
+
+export type BundledFontManifest = {
+  fonts: ReadonlyMap<string, BundledFont>;
+  metricSubstitutes: ReadonlyMap<string, string>;
+};
+
+const DEFAULT_BUNDLED_FONTS: readonly BundledFont[] = [
+  {
+    family: "Carlito",
+    regularUrl: "/fonts/carlito/Carlito-Regular.woff2",
+    boldUrl: "/fonts/carlito/Carlito-Bold.woff2",
+    italicUrl: "/fonts/carlito/Carlito-Italic.woff2",
+    boldItalicUrl: "/fonts/carlito/Carlito-BoldItalic.woff2",
+  },
+  {
+    family: "Caladea",
+    regularUrl: "/fonts/caladea/Caladea-Regular.woff2",
+    boldUrl: "/fonts/caladea/Caladea-Bold.woff2",
+    italicUrl: "/fonts/caladea/Caladea-Italic.woff2",
+    boldItalicUrl: "/fonts/caladea/Caladea-BoldItalic.woff2",
+  },
+  {
+    family: "Liberation Sans",
+    regularUrl: "/fonts/liberation-sans/LiberationSans-Regular.woff2",
+    boldUrl: "/fonts/liberation-sans/LiberationSans-Bold.woff2",
+    italicUrl: "/fonts/liberation-sans/LiberationSans-Italic.woff2",
+    boldItalicUrl: "/fonts/liberation-sans/LiberationSans-BoldItalic.woff2",
+  },
+  {
+    family: "Liberation Serif",
+    regularUrl: "/fonts/liberation-serif/LiberationSerif-Regular.woff2",
+    boldUrl: "/fonts/liberation-serif/LiberationSerif-Bold.woff2",
+    italicUrl: "/fonts/liberation-serif/LiberationSerif-Italic.woff2",
+    boldItalicUrl: "/fonts/liberation-serif/LiberationSerif-BoldItalic.woff2",
+  },
+  {
+    family: "Liberation Mono",
+    regularUrl: "/fonts/liberation-mono/LiberationMono-Regular.woff2",
+    boldUrl: "/fonts/liberation-mono/LiberationMono-Bold.woff2",
+    italicUrl: "/fonts/liberation-mono/LiberationMono-Italic.woff2",
+    boldItalicUrl: "/fonts/liberation-mono/LiberationMono-BoldItalic.woff2",
+  },
+  {
+    family: "Open Sans",
+    regularUrl: "/fonts/open-sans/OpenSans-Regular.woff2",
+    boldUrl: "/fonts/open-sans/OpenSans-Bold.woff2",
+    italicUrl: "/fonts/open-sans/OpenSans-Italic.woff2",
+    boldItalicUrl: "/fonts/open-sans/OpenSans-BoldItalic.woff2",
+  },
+  {
+    family: "Roboto",
+    regularUrl: "/fonts/roboto/Roboto-Regular.woff2",
+    boldUrl: "/fonts/roboto/Roboto-Bold.woff2",
+    italicUrl: "/fonts/roboto/Roboto-Italic.woff2",
+    boldItalicUrl: "/fonts/roboto/Roboto-BoldItalic.woff2",
+  },
+  {
+    family: "Lato",
+    regularUrl: "/fonts/lato/Lato-Regular.woff2",
+    boldUrl: "/fonts/lato/Lato-Bold.woff2",
+    italicUrl: "/fonts/lato/Lato-Italic.woff2",
+    boldItalicUrl: "/fonts/lato/Lato-BoldItalic.woff2",
+  },
+];
+
+const DEFAULT_METRIC_SUBSTITUTES: ReadonlyArray<readonly [string, string]> = [
+  ["Calibri", "Carlito"],
+  ["Calibri Light", "Carlito"],
+  ["Cambria", "Caladea"],
+  ["Cambria Math", "Caladea"],
+  ["Aptos", "Carlito"],
+  ["Aptos Display", "Carlito"],
+  ["Arial", "Liberation Sans"],
+  ["Helvetica", "Liberation Sans"],
+  ["Times New Roman", "Liberation Serif"],
+  ["Times", "Liberation Serif"],
+  ["Courier New", "Liberation Mono"],
+  ["Courier", "Liberation Mono"],
+];
+
+function normalize(family: string): string {
+  return family.trim().toLowerCase();
+}
+
+export function buildBundledManifest(
+  fonts: readonly BundledFont[] = DEFAULT_BUNDLED_FONTS,
+  substitutes: ReadonlyArray<readonly [string, string]> = DEFAULT_METRIC_SUBSTITUTES,
+  additional: readonly BundledFont[] = [],
+): BundledFontManifest {
+  const fontMap = new Map<string, BundledFont>();
+  for (const font of fonts) {
+    fontMap.set(normalize(font.family), font);
+  }
+  for (const font of additional) {
+    fontMap.set(normalize(font.family), font);
+  }
+  const subMap = new Map<string, string>();
+  for (const [from, to] of substitutes) {
+    subMap.set(normalize(from), to);
+  }
+  return { fonts: fontMap, metricSubstitutes: subMap };
+}
+
+export function lookupBundled(
+  manifest: BundledFontManifest,
+  family: string,
+): BundledFont | null {
+  const direct = manifest.fonts.get(normalize(family));
+  if (direct) return direct;
+  const substitute = manifest.metricSubstitutes.get(normalize(family));
+  if (!substitute) return null;
+  return manifest.fonts.get(normalize(substitute)) ?? null;
+}
+
+export function getMetricSubstitute(
+  manifest: BundledFontManifest,
+  family: string,
+): string | null {
+  return manifest.metricSubstitutes.get(normalize(family)) ?? null;
+}
+
+export const FALLBACK_BUNDLED_FAMILY = "Liberation Serif";

package/src/fonts/registry.test.ts

@@ -0,0 +1,233 @@
+import { describe, it, expect } from "vitest";
+import { buildFontRegistry } from "./registry";
+import {
+  buildBundledManifest,
+  lookupBundled,
+  getMetricSubstitute,
+} from "./bundled";
+import { parseFontTable } from "../parse/font_table";
+
+describe("bundled manifest", () => {
+  it("maps Calibri → Carlito (metric substitute)", () => {
+    const m = buildBundledManifest();
+    expect(getMetricSubstitute(m, "Calibri")).toBe("Carlito");
+    const bundled = lookupBundled(m, "Calibri");
+    expect(bundled?.family).toBe("Carlito");
+  });
+
+  it("maps Cambria → Caladea, Aptos → Carlito", () => {
+    const m = buildBundledManifest();
+    expect(getMetricSubstitute(m, "Cambria")).toBe("Caladea");
+    expect(getMetricSubstitute(m, "Aptos")).toBe("Carlito");
+  });
+
+  it("returns the bundled font directly when name matches", () => {
+    const m = buildBundledManifest();
+    expect(lookupBundled(m, "Roboto")?.family).toBe("Roboto");
+    expect(getMetricSubstitute(m, "Roboto")).toBeNull();
+  });
+
+  it("returns null for completely unknown families", () => {
+    const m = buildBundledManifest();
+    expect(lookupBundled(m, "ZZZ Custom Font")).toBeNull();
+  });
+});
+
+describe("font registry cascade", () => {
+  it("falls back to bundled metric substitute and flags substitutedFor", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [],
+    });
+    const result = reg.resolve({
+      requestedFamily: "Calibri",
+      weight: 400,
+      style: "normal",
+    });
+    expect(result.resource.family).toBe("Carlito");
+    expect(result.resource.substitutedFor).toBe("Calibri");
+    expect(result.resource.source.kind).toBe("bundled");
+  });
+
+  it("does not flag substitutedFor when the bundled family matches the request", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [],
+    });
+    const result = reg.resolve({
+      requestedFamily: "Carlito",
+      weight: 400,
+      style: "normal",
+    });
+    expect(result.resource.family).toBe("Carlito");
+    expect(result.resource.substitutedFor).toBeNull();
+  });
+
+  it("workspace fonts win over bundled metric substitutes", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [
+        {
+          family: "Calibri",
+          regular: { fileId: "fil_workspace_calibri" },
+          bold: null,
+          italic: null,
+          boldItalic: null,
+        },
+      ],
+    });
+    const result = reg.resolve({
+      requestedFamily: "Calibri",
+      weight: 400,
+      style: "normal",
+    });
+    expect(result.resource.source).toEqual({
+      kind: "workspace",
+      fileId: "fil_workspace_calibri",
+    });
+    expect(result.resource.substitutedFor).toBeNull();
+  });
+
+  it("embedded fonts win over workspace and bundled", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [
+        {
+          name: "Calibri",
+          altName: null,
+          panose: null,
+          family: "swiss",
+          pitch: "variable",
+          charset: null,
+          embeddedRegular: {
+            relationshipId: "rId10",
+            obfuscationKey: "{12345}",
+          },
+          embeddedBold: null,
+          embeddedItalic: null,
+          embeddedBoldItalic: null,
+        },
+      ],
+      workspaceFonts: [
+        {
+          family: "Calibri",
+          regular: { fileId: "fil_workspace" },
+          bold: null,
+          italic: null,
+          boldItalic: null,
+        },
+      ],
+    });
+    const result = reg.resolve({
+      requestedFamily: "Calibri",
+      weight: 400,
+      style: "normal",
+    });
+    expect(result.resource.source).toEqual({
+      kind: "embedded",
+      partPath: "rId10",
+      obfuscationKey: "{12345}",
+    });
+  });
+
+  it("picks bold variant when weight >= 600", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [],
+    });
+    const result = reg.resolve({
+      requestedFamily: "Carlito",
+      weight: 700,
+      style: "normal",
+    });
+    expect(result.resource.weight).toBe(700);
+    expect(result.resource.style).toBe("normal");
+  });
+
+  it("picks bold-italic when bold + italic requested", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [],
+    });
+    const result = reg.resolve({
+      requestedFamily: "Liberation Serif",
+      weight: 700,
+      style: "italic",
+    });
+    expect(result.resource.weight).toBe(700);
+    expect(result.resource.style).toBe("italic");
+  });
+
+  it("falls back to Liberation Serif for completely unknown families", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [],
+    });
+    const result = reg.resolve({
+      requestedFamily: "NoSuchFontEverPlease",
+      weight: 400,
+      style: "normal",
+    });
+    expect(result.resource.family).toBe("Liberation Serif");
+    expect(result.resource.substitutedFor).toBe("NoSuchFontEverPlease");
+  });
+
+  it("caches resolved variant sets across calls", () => {
+    const reg = buildFontRegistry({
+      embeddedFonts: [],
+      workspaceFonts: [],
+    });
+    const a = reg.resolve({
+      requestedFamily: "Calibri",
+      weight: 400,
+      style: "normal",
+    });
+    const b = reg.resolve({
+      requestedFamily: "Calibri",
+      weight: 700,
+      style: "italic",
+    });
+    expect(a.variantSet).toBe(b.variantSet);
+  });
+});
+
+describe("fontTable parsing", () => {
+  it("returns [] when fontTable.xml is missing", () => {
+    const decls = parseFontTable(new Map());
+    expect(decls).toEqual([]);
+  });
+
+  it("parses font entries with PANOSE and embed refs", () => {
+    const xml = `<?xml version="1.0"?>
+<w:fonts xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+         xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <w:font w:name="Calibri">
+    <w:panose1 w:val="020F0502020204030204"/>
+    <w:family w:val="swiss"/>
+    <w:pitch w:val="variable"/>
+    <w:embedRegular r:id="rId1" w:fontKey="{ABC}"/>
+    <w:embedBold r:id="rId2"/>
+  </w:font>
+  <w:font w:name="Times New Roman">
+    <w:family w:val="roman"/>
+    <w:pitch w:val="variable"/>
+  </w:font>
+</w:fonts>`;
+    const parts = new Map([
+      ["word/fontTable.xml", new TextEncoder().encode(xml)],
+    ]);
+    const decls = parseFontTable(parts);
+    expect(decls).toHaveLength(2);
+    expect(decls[0].name).toBe("Calibri");
+    expect(decls[0].family).toBe("swiss");
+    expect(decls[0].panose?.bytes).toEqual([
+      0x02, 0x0f, 0x05, 0x02, 0x02, 0x02, 0x04, 0x03, 0x02, 0x04,
+    ]);
+    expect(decls[0].embeddedRegular).toEqual({
+      relationshipId: "rId1",
+      obfuscationKey: "{ABC}",
+    });
+    expect(decls[0].embeddedBold?.obfuscationKey).toBeNull();
+    expect(decls[1].family).toBe("roman");
+    expect(decls[1].embeddedRegular).toBeNull();
+  });
+});

package/src/fonts/registry.ts

@@ -0,0 +1,219 @@
+import {
+  buildBundledManifest,
+  FALLBACK_BUNDLED_FAMILY,
+  lookupBundled,
+  type BundledFontManifest,
+} from "./bundled";
+import type {
+  BundledFont,
+  FontDeclaration,
+  FontRegistry,
+  FontResource,
+  FontVariantSet,
+  FontWeight,
+  ResolveFontInput,
+  ResolveFontResult,
+  WorkspaceFont,
+} from "./types";
+
+export type BuildRegistryInput = {
+  embeddedFonts: readonly FontDeclaration[];
+  workspaceFonts: readonly WorkspaceFont[];
+  bundled?: BundledFontManifest;
+};
+
+function normalize(family: string): string {
+  return family.trim().toLowerCase();
+}
+
+function variantFromEmbedded(
+  decl: FontDeclaration,
+): FontVariantSet | null {
+  if (
+    !decl.embeddedRegular &&
+    !decl.embeddedBold &&
+    !decl.embeddedItalic &&
+    !decl.embeddedBoldItalic
+  ) {
+    return null;
+  }
+  const make = (
+    ref: NonNullable<FontDeclaration["embeddedRegular"]>,
+    weight: FontWeight,
+    style: "normal" | "italic",
+  ): FontResource => ({
+    family: decl.name,
+    style,
+    weight,
+    source: {
+      kind: "embedded",
+      partPath: ref.relationshipId,
+      obfuscationKey: ref.obfuscationKey,
+    },
+    substitutedFor: null,
+  });
+  return {
+    family: decl.name,
+    regular: decl.embeddedRegular
+      ? make(decl.embeddedRegular, 400, "normal")
+      : null,
+    bold: decl.embeddedBold ? make(decl.embeddedBold, 700, "normal") : null,
+    italic: decl.embeddedItalic
+      ? make(decl.embeddedItalic, 400, "italic")
+      : null,
+    boldItalic: decl.embeddedBoldItalic
+      ? make(decl.embeddedBoldItalic, 700, "italic")
+      : null,
+  };
+}
+
+function variantFromWorkspace(font: WorkspaceFont): FontVariantSet {
+  const make = (
+    ref: NonNullable<WorkspaceFont["regular"]>,
+    weight: FontWeight,
+    style: "normal" | "italic",
+  ): FontResource => ({
+    family: font.family,
+    style,
+    weight,
+    source: { kind: "workspace", fileId: ref.fileId },
+    substitutedFor: null,
+  });
+  return {
+    family: font.family,
+    regular: font.regular ? make(font.regular, 400, "normal") : null,
+    bold: font.bold ? make(font.bold, 700, "normal") : null,
+    italic: font.italic ? make(font.italic, 400, "italic") : null,
+    boldItalic: font.boldItalic ? make(font.boldItalic, 700, "italic") : null,
+  };
+}
+
+function variantFromBundled(
+  bundled: BundledFont,
+  substitutedFor: string | null,
+): FontVariantSet {
+  const make = (
+    url: string,
+    weight: FontWeight,
+    style: "normal" | "italic",
+  ): FontResource => ({
+    family: bundled.family,
+    style,
+    weight,
+    source: { kind: "bundled", assetUrl: url },
+    substitutedFor,
+  });
+  return {
+    family: bundled.family,
+    regular: bundled.regularUrl
+      ? make(bundled.regularUrl, 400, "normal")
+      : null,
+    bold: bundled.boldUrl ? make(bundled.boldUrl, 700, "normal") : null,
+    italic: bundled.italicUrl ? make(bundled.italicUrl, 400, "italic") : null,
+    boldItalic: bundled.boldItalicUrl
+      ? make(bundled.boldItalicUrl, 700, "italic")
+      : null,
+  };
+}
+
+function pickResource(
+  set: FontVariantSet,
+  weight: FontWeight,
+  style: "normal" | "italic",
+): FontResource | null {
+  const wantBold = weight >= 600;
+  if (wantBold && style === "italic" && set.boldItalic) return set.boldItalic;
+  if (wantBold && set.bold) return set.bold;
+  if (style === "italic" && set.italic) return set.italic;
+  if (set.regular) return set.regular;
+  return set.bold ?? set.italic ?? set.boldItalic ?? null;
+}
+
+export function buildFontRegistry(input: BuildRegistryInput): FontRegistry {
+  const bundled = input.bundled ?? buildBundledManifest();
+
+  const embeddedSets = new Map<string, FontVariantSet>();
+  for (const decl of input.embeddedFonts) {
+    const set = variantFromEmbedded(decl);
+    if (set) embeddedSets.set(normalize(decl.name), set);
+  }
+
+  const workspaceSets = new Map<string, FontVariantSet>();
+  for (const font of input.workspaceFonts) {
+    workspaceSets.set(normalize(font.family), variantFromWorkspace(font));
+  }
+
+  const variantCache = new Map<string, FontVariantSet>();
+
+  for (const bundledFont of bundled.fonts.values()) {
+    variantCache.set(
+      normalize(bundledFont.family),
+      variantFromBundled(bundledFont, null),
+    );
+  }
+
+  const resolveVariantSet = (requested: string): FontVariantSet => {
+    const cacheKey = normalize(requested);
+    const cached = variantCache.get(cacheKey);
+    if (cached) return cached;
+
+    const embedded = embeddedSets.get(cacheKey);
+    if (embedded) {
+      variantCache.set(cacheKey, embedded);
+      return embedded;
+    }
+
+    const workspace = workspaceSets.get(cacheKey);
+    if (workspace) {
+      variantCache.set(cacheKey, workspace);
+      return workspace;
+    }
+
+    const direct = lookupBundled(bundled, requested);
+    if (direct) {
+      const substituted =
+        normalize(direct.family) === cacheKey ? null : requested;
+      const set = variantFromBundled(direct, substituted);
+      variantCache.set(cacheKey, set);
+      return set;
+    }
+
+    const fallback = lookupBundled(bundled, FALLBACK_BUNDLED_FAMILY);
+    if (!fallback) {
+      throw new Error(
+        `Bundled font registry missing fallback family ${FALLBACK_BUNDLED_FAMILY}`,
+      );
+    }
+    const set = variantFromBundled(fallback, requested);
+    variantCache.set(cacheKey, set);
+    return set;
+  };
+
+  const resolve = (input: ResolveFontInput): ResolveFontResult => {
+    const variantSet = resolveVariantSet(input.requestedFamily);
+    const resource = pickResource(variantSet, input.weight, input.style);
+    if (!resource) {
+      throw new Error(
+        `Font registry produced empty variant set for ${input.requestedFamily}`,
+      );
+    }
+    return { resource, variantSet };
+  };
+
+  const listVariantSets = (): FontVariantSet[] => {
+    const out: FontVariantSet[] = [];
+    const seen = new Set<string>();
+    const collect = (set: FontVariantSet) => {
+      const key = normalize(set.family);
+      if (seen.has(key)) return;
+      seen.add(key);
+      out.push(set);
+    };
+    for (const set of embeddedSets.values()) collect(set);
+    for (const set of workspaceSets.values()) collect(set);
+    for (const set of variantCache.values()) collect(set);
+    return out;
+  };
+
+  return { resolve, listVariantSets };
+}

package/src/fonts/types.ts

@@ -0,0 +1,83 @@
+export type FontStyle = "normal" | "italic";
+export type FontWeight = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
+
+export type FontScript = "ascii" | "hAnsi" | "eastAsia" | "complexScript";
+
+export type FontSource =
+  | { kind: "embedded"; partPath: string; obfuscationKey: string | null }
+  | { kind: "workspace"; fileId: string }
+  | { kind: "bundled"; assetUrl: string }
+  | { kind: "system" };
+
+export type FontResource = {
+  family: string;
+  style: FontStyle;
+  weight: FontWeight;
+  source: FontSource;
+  substitutedFor: string | null;
+};
+
+export type FontVariantSet = {
+  family: string;
+  regular: FontResource | null;
+  bold: FontResource | null;
+  italic: FontResource | null;
+  boldItalic: FontResource | null;
+};
+
+export type Panose = {
+  bytes: readonly number[];
+};
+
+export type FontFamilyKind =
+  | "roman"
+  | "swiss"
+  | "modern"
+  | "script"
+  | "decorative"
+  | "auto";
+
+export type FontDeclaration = {
+  name: string;
+  altName: string | null;
+  panose: Panose | null;
+  family: FontFamilyKind;
+  pitch: "fixed" | "variable" | "default";
+  charset: string | null;
+  embeddedRegular: { relationshipId: string; obfuscationKey: string | null } | null;
+  embeddedBold: { relationshipId: string; obfuscationKey: string | null } | null;
+  embeddedItalic: { relationshipId: string; obfuscationKey: string | null } | null;
+  embeddedBoldItalic: { relationshipId: string; obfuscationKey: string | null } | null;
+};
+
+export type WorkspaceFont = {
+  family: string;
+  regular: { fileId: string } | null;
+  bold: { fileId: string } | null;
+  italic: { fileId: string } | null;
+  boldItalic: { fileId: string } | null;
+};
+
+export type BundledFont = {
+  family: string;
+  regularUrl: string | null;
+  boldUrl: string | null;
+  italicUrl: string | null;
+  boldItalicUrl: string | null;
+};
+
+export type ResolveFontInput = {
+  requestedFamily: string;
+  weight: FontWeight;
+  style: FontStyle;
+};
+
+export type ResolveFontResult = {
+  resource: FontResource;
+  variantSet: FontVariantSet;
+};
+
+export type FontRegistry = {
+  resolve(input: ResolveFontInput): ResolveFontResult;
+  listVariantSets(): readonly FontVariantSet[];
+};