@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/io/ooxml/parse-theme.ts

@@ -0,0 +1,314 @@
+import type {
+  ThemeColorScheme,
+  ThemeDefinition,
+  ThemeFontScheme,
+} from "../../model/canonical-document.ts";
+
+// ---- XML node types (inline, no external dep) ----
+
+interface XmlElementNode {
+  type: "element";
+  name: string;
+  attributes: Record<string, string>;
+  children: XmlNode[];
+}
+
+interface XmlTextNode {
+  type: "text";
+  text: string;
+}
+
+type XmlNode = XmlElementNode | XmlTextNode;
+
+// ---- Well-known DrawingML color slot names ----
+
+const COLOR_SLOTS = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink",
+] as const;
+
+// ---- Public API ----
+
+/**
+ * Parse a DrawingML theme1.xml part into a ThemeDefinition.
+ * Returns an empty ThemeDefinition if the XML is empty or malformed.
+ */
+export function parseThemeXml(xml: string): ThemeDefinition {
+  if (!xml.trim()) {
+    return {};
+  }
+
+  const root = parseXml(xml);
+  const themeElement = findChildElementOptional(root, "theme");
+  if (!themeElement) {
+    return {};
+  }
+
+  const themeName =
+    themeElement.attributes["name"] ??
+    themeElement.attributes["a:name"] ??
+    undefined;
+
+  const themeElements = findChildElementOptional(themeElement, "themeElements");
+  if (!themeElements) {
+    return { ...(themeName ? { name: themeName } : {}) };
+  }
+
+  const colorScheme = parseColorScheme(
+    findChildElementOptional(themeElements, "clrScheme"),
+  );
+  const fontScheme = parseFontScheme(
+    findChildElementOptional(themeElements, "fontScheme"),
+  );
+
+  const result: ThemeDefinition = {};
+  if (themeName) {
+    result.name = themeName;
+  }
+  if (colorScheme) {
+    result.colorScheme = colorScheme;
+  }
+  if (fontScheme) {
+    result.fontScheme = fontScheme;
+  }
+
+  return result;
+}
+
+// ---- Internal helpers ----
+
+function parseColorScheme(
+  element: XmlElementNode | undefined,
+): ThemeColorScheme | undefined {
+  if (!element) {
+    return undefined;
+  }
+
+  const schemeName =
+    element.attributes["name"] ?? element.attributes["a:name"] ?? "";
+  const colors: Record<string, string> = {};
+
+  for (const slot of COLOR_SLOTS) {
+    const slotElement = findChildElementOptional(element, slot);
+    if (!slotElement) {
+      continue;
+    }
+
+    const color = extractColorValue(slotElement);
+    if (color) {
+      colors[slot] = color;
+    }
+  }
+
+  return { name: schemeName, colors };
+}
+
+function extractColorValue(slotElement: XmlElementNode): string | undefined {
+  for (const child of slotElement.children) {
+    if (child.type !== "element") {
+      continue;
+    }
+
+    const name = localName(child.name);
+
+    if (name === "srgbClr") {
+      const val = child.attributes["val"] ?? child.attributes["a:val"] ?? "";
+      if (val) {
+        return `#${val.toUpperCase()}`;
+      }
+    } else if (name === "sysClr") {
+      // Use lastClr as the resolved color value
+      const lastClr =
+        child.attributes["lastClr"] ??
+        child.attributes["a:lastClr"] ??
+        "";
+      if (lastClr) {
+        return `#${lastClr.toUpperCase()}`;
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function parseFontScheme(
+  element: XmlElementNode | undefined,
+): ThemeFontScheme | undefined {
+  if (!element) {
+    return undefined;
+  }
+
+  const schemeName =
+    element.attributes["name"] ?? element.attributes["a:name"] ?? "";
+
+  const majorFontElement = findChildElementOptional(element, "majorFont");
+  const minorFontElement = findChildElementOptional(element, "minorFont");
+
+  const majorFont = majorFontElement
+    ? extractFontTypeface(majorFontElement)
+    : undefined;
+  const minorFont = minorFontElement
+    ? extractFontTypeface(minorFontElement)
+    : undefined;
+
+  const result: ThemeFontScheme = { name: schemeName };
+  if (majorFont) {
+    result.majorFont = majorFont;
+  }
+  if (minorFont) {
+    result.minorFont = minorFont;
+  }
+
+  return result;
+}
+
+function extractFontTypeface(
+  fontGroupElement: XmlElementNode,
+): string | undefined {
+  const latinElement = findChildElementOptional(fontGroupElement, "latin");
+  if (latinElement) {
+    return (
+      latinElement.attributes["typeface"] ??
+      latinElement.attributes["a:typeface"] ??
+      undefined
+    );
+  }
+  return undefined;
+}
+
+function findChildElementOptional(
+  node: XmlElementNode,
+  childLocalName: string,
+): XmlElementNode | undefined {
+  return node.children.find(
+    (entry): entry is XmlElementNode =>
+      entry.type === "element" && localName(entry.name) === childLocalName,
+  );
+}
+
+function localName(name: string): string {
+  const idx = name.indexOf(":");
+  return idx >= 0 ? name.slice(idx + 1) : name;
+}
+
+// ---- Minimal XML parser ----
+
+function parseXml(xml: string): XmlElementNode {
+  const root: XmlElementNode = {
+    type: "element",
+    name: "__root__",
+    attributes: {},
+    children: [],
+  };
+  const stack: XmlElementNode[] = [root];
+  let cursor = 0;
+
+  while (cursor < xml.length) {
+    if (xml.startsWith("<!--", cursor)) {
+      const end = xml.indexOf("-->", cursor);
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<?", cursor)) {
+      const end = xml.indexOf("?>", cursor);
+      cursor = end >= 0 ? end + 2 : xml.length;
+      continue;
+    }
+
+    if (xml.startsWith("<![CDATA[", cursor)) {
+      const end = xml.indexOf("]]>", cursor);
+      const textEnd = end >= 0 ? end : xml.length;
+      stack[stack.length - 1]?.children.push({
+        type: "text",
+        text: xml.slice(cursor + 9, textEnd),
+      });
+      cursor = end >= 0 ? end + 3 : xml.length;
+      continue;
+    }
+
+    if (xml[cursor] !== "<") {
+      const nextTag = xml.indexOf("<", cursor);
+      const end = nextTag >= 0 ? nextTag : xml.length;
+      const text = decodeXmlEntities(xml.slice(cursor, end));
+      if (text.trim().length > 0 || (text.length > 0 && stack.length > 1)) {
+        stack[stack.length - 1]?.children.push({ type: "text", text });
+      }
+      cursor = end;
+      continue;
+    }
+
+    if (xml[cursor + 1] === "/") {
+      const end = xml.indexOf(">", cursor);
+      if (end < 0) break;
+      stack.pop();
+      cursor = end + 1;
+      continue;
+    }
+
+    const tagEnd = xml.indexOf(">", cursor);
+    if (tagEnd < 0) break;
+
+    const tagContent = xml.slice(cursor + 1, tagEnd);
+    const selfClosing = tagContent.endsWith("/");
+    const normalized = selfClosing ? tagContent.slice(0, -1).trimEnd() : tagContent;
+
+    const spaceIndex = normalized.search(/\s/);
+    const tagName = spaceIndex >= 0 ? normalized.slice(0, spaceIndex) : normalized;
+    const attrString = spaceIndex >= 0 ? normalized.slice(spaceIndex + 1) : "";
+    const attributes = parseAttributes(attrString);
+
+    const element: XmlElementNode = {
+      type: "element",
+      name: tagName,
+      attributes,
+      children: [],
+    };
+
+    stack[stack.length - 1]?.children.push(element);
+
+    if (!selfClosing) {
+      stack.push(element);
+    }
+
+    cursor = tagEnd + 1;
+  }
+
+  return root;
+}
+
+function parseAttributes(attrString: string): Record<string, string> {
+  const attrs: Record<string, string> = {};
+  const pattern = /([A-Za-z_:][A-Za-z0-9:._-]*)\s*=\s*("([^"]*)"|'([^']*)')/gu;
+  for (const match of attrString.matchAll(pattern)) {
+    const name = match[1];
+    const value = match[3] ?? match[4] ?? "";
+    if (name) {
+      attrs[name] = decodeXmlEntities(value);
+    }
+  }
+  return attrs;
+}
+
+function decodeXmlEntities(text: string): string {
+  return text
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number.parseInt(dec, 10)))
+    .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) =>
+      String.fromCodePoint(Number.parseInt(hex, 16)),
+    );
+}

package/src/io/ooxml/part-manifest.ts

@@ -0,0 +1,136 @@
+export const CONTENT_TYPES_PATH = "/[Content_Types].xml";
+export const PACKAGE_RELATIONSHIPS_PATH = "/_rels/.rels";
+
+export type OpcCompressionMethod = "store" | "deflate";
+export type OpcSurfaceKind = "content" | "relationships" | "content-types";
+export type OpcRelationshipTargetMode = "internal" | "external";
+
+export interface OpcRelationship {
+  id: string;
+  type: string;
+  target: string;
+  targetMode: OpcRelationshipTargetMode;
+}
+
+export interface OpcPartManifestEntry {
+  path: string;
+  surfaceKind: OpcSurfaceKind;
+  contentType: string | null;
+  relationshipsPartPath: string | null;
+  relationships: OpcRelationship[];
+  compression: OpcCompressionMethod;
+  byteLength: number;
+}
+
+export interface OpcContentTypesManifest {
+  defaults: Record<string, string>;
+  overrides: Record<string, string>;
+}
+
+export interface OpcPackageManifest {
+  contentTypes: OpcContentTypesManifest;
+  packageRelationships: OpcRelationship[];
+  parts: OpcPartManifestEntry[];
+}
+
+export interface OpcPackagePart {
+  path: string;
+  surfaceKind: OpcSurfaceKind;
+  contentType: string | null;
+  relationshipsPartPath: string | null;
+  relationships: OpcRelationship[];
+  compression: OpcCompressionMethod;
+  bytes: Uint8Array;
+  crc32: number;
+}
+
+export function normalizePartPath(path: string): string {
+  const normalized = path.replace(/\\/g, "/").trim();
+  if (normalized.length === 0) {
+    throw new Error("OPC part path must not be empty.");
+  }
+
+  const withLeadingSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  const segments = withLeadingSlash.split("/");
+  const resolved: string[] = [];
+
+  for (const segment of segments) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+
+    if (segment === "..") {
+      if (resolved.length === 0) {
+        throw new Error(`OPC part path escapes package root: ${path}`);
+      }
+
+      resolved.pop();
+      continue;
+    }
+
+    resolved.push(segment);
+  }
+
+  return `/${resolved.join("/")}`;
+}
+
+export function getExtension(partPath: string): string {
+  const normalized = normalizePartPath(partPath);
+  const lastSlash = normalized.lastIndexOf("/");
+  const lastDot = normalized.lastIndexOf(".");
+  if (lastDot <= lastSlash) {
+    return "";
+  }
+
+  return normalized.slice(lastDot + 1).toLowerCase();
+}
+
+export function getRelationshipsPartPath(partPath?: string | null): string {
+  if (!partPath) {
+    return PACKAGE_RELATIONSHIPS_PATH;
+  }
+
+  const normalized = normalizePartPath(partPath);
+  const lastSlash = normalized.lastIndexOf("/");
+  const directory = lastSlash <= 0 ? "" : normalized.slice(0, lastSlash);
+  const filename = normalized.slice(lastSlash + 1);
+  return `${directory}/_rels/${filename}.rels`;
+}
+
+export function getSourcePartPathFromRelationshipsPart(path: string): string | null {
+  const normalized = normalizePartPath(path);
+  if (normalized === PACKAGE_RELATIONSHIPS_PATH) {
+    return null;
+  }
+
+  const marker = "/_rels/";
+  const markerIndex = normalized.lastIndexOf(marker);
+  if (markerIndex === -1 || !normalized.endsWith(".rels")) {
+    throw new Error(`Invalid OPC relationships part path: ${path}`);
+  }
+
+  return normalizePartPath(
+    `${normalized.slice(0, markerIndex)}${normalized.slice(markerIndex + marker.length, -".rels".length)}`,
+  );
+}
+
+export function resolveRelationshipTarget(
+  sourcePartPath: string | null,
+  relationship: Pick<OpcRelationship, "target" | "targetMode">,
+): string {
+  if (relationship.targetMode === "external") {
+    return relationship.target;
+  }
+
+  if (relationship.target.startsWith("/")) {
+    return normalizePartPath(relationship.target);
+  }
+
+  const basePath = sourcePartPath ? normalizePartPath(sourcePartPath) : "/";
+  const baseDir = basePath === "/" ? "/" : basePath.slice(0, basePath.lastIndexOf("/") + 1);
+  return normalizePartPath(`${baseDir}${relationship.target}`);
+}
+
+export function comparePartPaths(a: string, b: string): number {
+  return normalizePartPath(a).localeCompare(normalizePartPath(b));
+}