@arnilo/prism-tools 0.0.0-stage → 0.13.0

package/work/src/documents/translate/docx.ts

@@ -0,0 +1,292 @@
+import {
+  type DocumentOptions,
+  generateDocumentSync,
+  parseDocumentSync as ooParseDocument,
+  type ParagraphOptions,
+  type SectionChild,
+  type TableOptions,
+} from "@office-open/docx";
+import type { CellValue, DocBlock, DocModel, DocRun, ListItem, TableBlock } from "../types.js";
+
+function docRunToRunOptions(run: DocRun) {
+  return {
+    text: run.text,
+    bold: run.bold,
+    italic: run.italic,
+    underline: run.underline ? ({ type: "single" } as const) : undefined,
+    strike: run.strikethrough,
+    font: run.code ? { name: "Courier New" } : undefined,
+  };
+}
+
+function listItemChildren(item: string | ListItem) {
+  if (typeof item === "string") return [{ text: item }];
+  if (item.runs && item.runs.length > 0) return item.runs.map(docRunToRunOptions);
+  return [{ text: item.text ?? "" }];
+}
+
+function cellValueToString(value: CellValue): string {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if ("type" in value) {
+    return value.value;
+  }
+  if ("formula" in value) {
+    return value.cachedValue !== undefined && value.cachedValue !== null ? String(value.cachedValue) : value.formula;
+  }
+  return "";
+}
+
+function blockToSectionChildren(block: DocBlock): SectionChild[] {
+  switch (block.type) {
+    case "heading": {
+      const headingKey = `Heading${block.level}` as const;
+      return [
+        {
+          paragraph: {
+            heading: headingKey,
+            children: [{ text: block.text }],
+          },
+        },
+      ];
+    }
+    case "paragraph": {
+      const children =
+        block.runs && block.runs.length > 0 ? block.runs.map(docRunToRunOptions) : block.text !== undefined ? [{ text: block.text }] : [];
+      return [
+        {
+          paragraph: {
+            children,
+          },
+        },
+      ];
+    }
+    case "list": {
+      const numbering = { reference: block.ordered ? "ordered" : "bullet", level: 0 };
+      return block.items.map((item) => ({
+        paragraph: {
+          numbering,
+          children: listItemChildren(item),
+        },
+      }));
+    }
+    case "table": {
+      const tableRows = [];
+      if (block.headers && block.headers.length > 0) {
+        tableRows.push({
+          cells: block.headers.map((h) => ({
+            children: [
+              {
+                paragraph: {
+                  children: [{ text: h, bold: true }],
+                },
+              },
+            ],
+          })),
+        });
+      }
+      for (const row of block.cells) {
+        tableRows.push({
+          cells: row.map((cell) => ({
+            children: [
+              {
+                paragraph: {
+                  children: [{ text: cellValueToString(cell) }],
+                },
+              },
+            ],
+          })),
+        });
+      }
+      return [
+        {
+          table: {
+            rows: tableRows,
+          } as TableOptions,
+        },
+      ];
+    }
+    case "page-break": {
+      return [
+        {
+          paragraph: {
+            children: [{ break: 1 }],
+          },
+        },
+      ];
+    }
+    case "image": {
+      const label = block.alt ? `[Image: ${block.alt}]` : "[Image]";
+      return [
+        {
+          paragraph: {
+            children: [{ text: label, italic: true }],
+          },
+        },
+      ];
+    }
+    case "chart": {
+      const title = block.title ? ` - ${block.title}` : "";
+      const label = `[Chart: ${block.chartType}${title}]`;
+      return [
+        {
+          paragraph: {
+            children: [{ text: label, bold: true }],
+          },
+        },
+      ];
+    }
+    default:
+      return [];
+  }
+}
+
+export function docModelToDocxOptions(model: DocModel): DocumentOptions {
+  const children: SectionChild[] = [];
+  if (model.title) {
+    children.push({
+      paragraph: {
+        heading: "Title",
+        children: [{ text: model.title }],
+      },
+    });
+  }
+
+  for (const block of model.blocks) {
+    children.push(...blockToSectionChildren(block));
+  }
+
+  return {
+    ...(model.blocks.some((block) => block.type === "list")
+      ? {
+          numbering: {
+            abstractNumberings: [
+              { reference: "bullet", instanceCount: 1, levels: [{ level: 0, format: "bullet" as const, text: "●" }] },
+              { reference: "ordered", instanceCount: 1, levels: [{ level: 0, format: "decimal" as const, text: "%1." }] },
+            ],
+          },
+        }
+      : {}),
+    sections: [
+      {
+        children,
+      },
+    ],
+  };
+}
+
+export function generateDocxBytes(model: DocModel): Uint8Array {
+  const options = docModelToDocxOptions(model);
+  const result = generateDocumentSync(options);
+  return new Uint8Array(result);
+}
+
+function extractParagraphText(p: ParagraphOptions | undefined): string {
+  if (!p) return "";
+  if (p.text) return p.text;
+  if (!p.children) return "";
+  const parts: string[] = [];
+  for (const child of p.children) {
+    if (typeof child === "string") {
+      parts.push(child);
+    } else if (child && typeof child === "object" && "text" in child && typeof child.text === "string") {
+      parts.push(child.text);
+    }
+  }
+  return parts.join("");
+}
+
+function extractParagraphRuns(p: ParagraphOptions | undefined): DocRun[] | undefined {
+  if (!p?.children || p.children.length === 0) return undefined;
+  const runs: DocRun[] = [];
+  for (const child of p.children) {
+    if (typeof child === "string") {
+      runs.push({ text: child });
+    } else if (child && typeof child === "object" && "text" in child && typeof child.text === "string") {
+      runs.push({
+        text: child.text,
+        bold: (child as { bold?: boolean }).bold,
+        italic: (child as { italic?: boolean }).italic,
+        underline: (child as { underline?: unknown }).underline ? true : undefined,
+        strikethrough: (child as { strike?: boolean }).strike,
+        code: (child as { font?: { name?: string } }).font?.name === "Courier New" ? true : undefined,
+      });
+    }
+  }
+  return runs.length > 0 ? runs : undefined;
+}
+
+export function parseDocxBytes(bytes: Uint8Array): DocModel {
+  const parsed = ooParseDocument(bytes);
+  let title: string | undefined;
+  const blocks: DocBlock[] = [];
+
+  const sections = parsed.sections ?? [];
+  for (const section of sections) {
+    const children = (section.children ?? []) as Array<Record<string, unknown>>;
+    for (const child of children) {
+      if ("paragraph" in child) {
+        const p = child.paragraph as ParagraphOptions & { heading?: string };
+        const heading = p.heading;
+        const text = extractParagraphText(p);
+
+        if (heading === "Title" && !title) {
+          title = text;
+          continue;
+        }
+
+        if (heading && /^Heading[1-6]$/.test(heading)) {
+          const level = Number(heading.replace("Heading", "")) as 1 | 2 | 3 | 4 | 5 | 6;
+          blocks.push({
+            type: "heading",
+            level,
+            text,
+          });
+          continue;
+        }
+
+        if (p.children?.some((c) => typeof c === "object" && c !== null && "break" in c)) {
+          blocks.push({ type: "page-break" });
+          continue;
+        }
+
+        const runs = extractParagraphRuns(p);
+        blocks.push({
+          type: "paragraph",
+          text,
+          runs,
+        });
+      } else if ("table" in child) {
+        const t = child.table as { rows?: Array<{ cells?: Array<{ children?: Array<{ paragraph?: ParagraphOptions }> }> }> };
+        const rows = t.rows ?? [];
+        const tableCells: CellValue[][] = [];
+
+        for (const row of rows) {
+          const rowCells: CellValue[] = [];
+          for (const cell of row.cells ?? []) {
+            const cellText = (cell.children ?? []).map((c) => extractParagraphText(c.paragraph)).join("\n");
+            rowCells.push(cellText);
+          }
+          tableCells.push(rowCells);
+        }
+
+        const rowCount = tableCells.length;
+        const colCount = rowCount > 0 ? tableCells[0].length : 0;
+        blocks.push({
+          type: "table",
+          rows: rowCount,
+          columns: colCount,
+          cells: tableCells,
+        } as TableBlock);
+      }
+    }
+  }
+
+  return {
+    kind: "doc",
+    modelVersion: 1,
+    title,
+    blocks,
+  };
+}

package/work/src/documents/translate/pptx.ts

@@ -0,0 +1,304 @@
+import {
+  generatePresentationSync,
+  parsePresentationSync as ooParsePresentation,
+  type PresentationOptions,
+  type SlideChild,
+  type SlideOptions,
+} from "@office-open/pptx";
+import type { DeckModel, ListItem, SlideData, SlideLayout } from "../types.js";
+
+function bulletItemToString(item: string | ListItem): string {
+  if (typeof item === "string") return item;
+  if (item.runs && item.runs.length > 0) {
+    return item.runs.map((r) => r.text).join("");
+  }
+  return item.text ?? "";
+}
+
+function slideDataToSlideOptions(slide: SlideData): SlideOptions {
+  const children: SlideChild[] = [];
+  const titleText = slide.title ?? "";
+
+  switch (slide.layout) {
+    case "title": {
+      if (titleText) {
+        children.push({
+          shape: {
+            x: 100,
+            y: 150,
+            width: 800,
+            height: 100,
+            textBody: {
+              paragraphs: [{ text: titleText }],
+            },
+          },
+        });
+      }
+      if (slide.subtitle) {
+        children.push({
+          shape: {
+            x: 100,
+            y: 270,
+            width: 800,
+            height: 80,
+            textBody: {
+              paragraphs: [{ text: slide.subtitle }],
+            },
+          },
+        });
+      }
+      break;
+    }
+    case "section-header": {
+      if (titleText) {
+        children.push({
+          shape: {
+            x: 100,
+            y: 200,
+            width: 800,
+            height: 120,
+            textBody: {
+              paragraphs: [{ text: titleText }],
+            },
+          },
+        });
+      }
+      break;
+    }
+    case "two-column": {
+      if (titleText) {
+        children.push({
+          shape: {
+            x: 50,
+            y: 50,
+            width: 800,
+            height: 60,
+            textBody: {
+              paragraphs: [{ text: titleText }],
+            },
+          },
+        });
+      }
+      if (slide.bullets && slide.bullets.length > 0) {
+        const mid = Math.ceil(slide.bullets.length / 2);
+        const col1Paragraphs = slide.bullets.slice(0, mid).map((b) => ({ text: `• ${bulletItemToString(b)}` }));
+        const col2Paragraphs = slide.bullets.slice(mid).map((b) => ({ text: `• ${bulletItemToString(b)}` }));
+
+        children.push({
+          shape: {
+            x: 50,
+            y: 130,
+            width: 400,
+            height: 400,
+            textBody: {
+              paragraphs: col1Paragraphs,
+            },
+          },
+        });
+        if (col2Paragraphs.length > 0) {
+          children.push({
+            shape: {
+              x: 480,
+              y: 130,
+              width: 400,
+              height: 400,
+              textBody: {
+                paragraphs: col2Paragraphs,
+              },
+            },
+          });
+        }
+      }
+      break;
+    }
+    case "blank": {
+      if (titleText) {
+        children.push({
+          shape: {
+            x: 50,
+            y: 50,
+            width: 800,
+            height: 60,
+            textBody: {
+              paragraphs: [{ text: titleText }],
+            },
+          },
+        });
+      }
+      break;
+    }
+    default: {
+      if (titleText) {
+        children.push({
+          shape: {
+            x: 50,
+            y: 50,
+            width: 800,
+            height: 60,
+            textBody: {
+              paragraphs: [{ text: titleText }],
+            },
+          },
+        });
+      }
+      if (slide.bullets && slide.bullets.length > 0) {
+        const bulletParagraphs = slide.bullets.map((b) => ({ text: `• ${bulletItemToString(b)}` }));
+        children.push({
+          shape: {
+            x: 50,
+            y: 130,
+            width: 800,
+            height: 400,
+            textBody: {
+              paragraphs: bulletParagraphs,
+            },
+          },
+        });
+      }
+      break;
+    }
+  }
+
+  if (slide.image) {
+    const label = slide.image.alt ? `[Image: ${slide.image.alt}]` : "[Image]";
+    children.push({
+      shape: {
+        x: 500,
+        y: 150,
+        width: 300,
+        height: 200,
+        textBody: {
+          paragraphs: [{ text: label }],
+        },
+      },
+    });
+  }
+
+  if (slide.chart) {
+    const title = slide.chart.title ? ` - ${slide.chart.title}` : "";
+    const label = `[Chart: ${slide.chart.chartType}${title}]`;
+    children.push({
+      shape: {
+        x: 500,
+        y: 150,
+        width: 300,
+        height: 200,
+        textBody: {
+          paragraphs: [{ text: label }],
+        },
+      },
+    });
+  }
+
+  return {
+    children,
+    notes: slide.notes,
+  };
+}
+
+export function deckModelToPptxOptions(model: DeckModel): PresentationOptions {
+  return {
+    slides: model.slides.map(slideDataToSlideOptions),
+  };
+}
+
+export function generatePptxBytes(model: DeckModel): Uint8Array {
+  const options = deckModelToPptxOptions(model);
+  const result = generatePresentationSync(options);
+  return new Uint8Array(result);
+}
+
+function extractNotesText(notes: unknown): string | undefined {
+  if (!notes) return undefined;
+  if (typeof notes === "string") return notes;
+  if (typeof notes !== "object") return undefined;
+
+  const notesObj = notes as {
+    children?: Array<{
+      shape?: {
+        textBody?: {
+          paragraphs?: Array<{
+            text?: string;
+            children?: Array<{ text?: string }>;
+          }>;
+        };
+      };
+    }>;
+  };
+
+  if (!notesObj.children) return undefined;
+  const texts: string[] = [];
+  for (const child of notesObj.children) {
+    const paragraphs = child.shape?.textBody?.paragraphs ?? [];
+    for (const p of paragraphs) {
+      if (p.text) {
+        texts.push(p.text);
+      }
+      if (p.children) {
+        for (const c of p.children) {
+          if (c.text) texts.push(c.text);
+        }
+      }
+    }
+  }
+  return texts.length > 0 ? texts.join("\n") : undefined;
+}
+
+export function parsePptxBytes(bytes: Uint8Array): DeckModel {
+  const parsed = ooParsePresentation(bytes);
+  const slides: SlideData[] = [];
+
+  for (const slide of parsed.slides ?? []) {
+    let title: string | undefined;
+    let subtitle: string | undefined;
+    const bullets: string[] = [];
+
+    const children = slide.children ?? [];
+    for (const child of children) {
+      if ("shape" in child && child.shape) {
+        const paragraphs = child.shape.textBody?.paragraphs ?? [];
+        for (const p of paragraphs) {
+          let text = "";
+          if (typeof p === "string") {
+            text = p;
+          } else if (p && typeof p === "object") {
+            if ("text" in p && typeof (p as { text?: unknown }).text === "string") {
+              text = (p as { text: string }).text;
+            } else if ("children" in p && Array.isArray((p as { children?: unknown }).children)) {
+              const pChildren = (p as { children: Array<{ text?: string } | string> }).children;
+              text = pChildren.map((c) => (typeof c === "string" ? c : (c?.text ?? ""))).join("");
+            }
+          }
+          if (!text) continue;
+
+          if (!title) {
+            title = text;
+          } else if (text.startsWith("• ")) {
+            bullets.push(text.slice(2));
+          } else if (!subtitle && bullets.length === 0) {
+            subtitle = text;
+          } else {
+            bullets.push(text);
+          }
+        }
+      }
+    }
+
+    const notes = extractNotesText(slide.notes);
+    const layout: SlideLayout = title && subtitle && bullets.length === 0 ? "title" : "title-and-content";
+
+    slides.push({
+      layout,
+      title,
+      subtitle,
+      bullets: bullets.length > 0 ? bullets : undefined,
+      notes,
+    });
+  }
+
+  return {
+    kind: "deck",
+    modelVersion: 1,
+    slides,
+  };
+}