ppt-template-reuse 0.4.0-rc.2

package/src/core/paths.mjs

@@ -0,0 +1,60 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export function resolveEngineHome(explicitHome) {
+  return path.resolve(
+    explicitHome ||
+      process.env.PPT_TEMPLATE_REUSE_HOME ||
+      path.join(os.homedir(), ".ppt-template-reuse"),
+  );
+}
+
+export function resolveLibraryDir(explicitHome) {
+  return path.join(resolveEngineHome(explicitHome), "library");
+}
+
+export function resolveSessionsDir(explicitHome) {
+  return path.join(resolveEngineHome(explicitHome), "sessions");
+}
+
+export function legacyLibraryDir() {
+  return path.join(
+    path.join(os.homedir(), ".codex"),
+    "ppt-template-reuse",
+    "library",
+  );
+}
+
+async function exists(candidate) {
+  return Boolean(await fs.stat(candidate).catch(() => undefined));
+}
+
+export async function migrateLegacyCapsules(explicitHome) {
+  const home = resolveEngineHome(explicitHome);
+  const library = resolveLibraryDir(home);
+  const legacy = legacyLibraryDir();
+  await fs.mkdir(library, { recursive: true });
+  const indexPath = path.join(library, "legacy-capsules.json");
+  const prior = (await exists(indexPath))
+    ? JSON.parse(await fs.readFile(indexPath, "utf8"))
+    : { schemaVersion: 1, capsules: [] };
+  const known = new Set(prior.capsules.map((entry) => entry.sha256));
+  if (await exists(legacy)) {
+    const entries = await fs.readdir(legacy, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || known.has(entry.name)) continue;
+      const manifest = path.join(legacy, entry.name, "manifest.json");
+      if (!(await exists(manifest))) continue;
+      prior.capsules.push({
+        sha256: entry.name,
+        path: path.join(legacy, entry.name),
+        mode: "read-only-reference",
+      });
+      known.add(entry.name);
+    }
+  }
+  prior.capsules.sort((a, b) => a.sha256.localeCompare(b.sha256));
+  await fs.writeFile(indexPath, `${JSON.stringify(prior, null, 2)}\n`, "utf8");
+  return { home, library, legacy, imported: prior.capsules.length, indexPath };
+}

package/src/core/planner-lib.mjs

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export function parseArgs(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) result[key] = true;
+    else {
+      result[key] = next;
+      index += 1;
+    }
+  }
+  return result;
+}
+
+export function requireArg(args, key) {
+  const value = args[key];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`Missing required argument --${key}`);
+  }
+  return value;
+}
+
+export async function readJson(filePath) {
+  return JSON.parse(await fs.readFile(filePath, "utf8"));
+}
+
+export async function writeJson(filePath, value) {
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export async function exists(filePath) {
+  return Boolean(await fs.stat(filePath).catch(() => undefined));
+}
+
+export function textWidthUnits(value) {
+  let units = 0;
+  for (const character of [...String(value ?? "")]) {
+    if (/[\r\n]/u.test(character)) continue;
+    if (/\s/u.test(character)) units += 0.33;
+    else if (
+      /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\u3000-\u303f\uff01-\uff60]/u.test(
+        character,
+      )
+    ) {
+      units += 1;
+    } else if (/[A-Z]/u.test(character)) units += 0.68;
+    else if (/[a-z0-9]/u.test(character)) units += 0.55;
+    else if (/[\p{Punctuation}]/u.test(character)) units += 0.45;
+    else if (/[\p{Symbol}]/u.test(character)) units += 1;
+    else units += 0.75;
+  }
+  return Number(units.toFixed(3));
+}

package/src/core/pptx-package.mjs

@@ -0,0 +1,227 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import JSZip from "jszip";
+import { DOMParser, XMLSerializer } from "@xmldom/xmldom";
+
+const parser = new DOMParser();
+const serializer = new XMLSerializer();
+
+export function parseXml(xml) {
+  return parser.parseFromString(String(xml), "application/xml");
+}
+
+export function serializeXml(document) {
+  return serializer.serializeToString(document);
+}
+
+export function localName(node) {
+  return String(node?.localName || node?.nodeName || "").split(":").pop();
+}
+
+export function elements(node, wanted) {
+  const result = [];
+  const visit = (current) => {
+    for (const child of Array.from(current?.childNodes || [])) {
+      if (child.nodeType === 1 && (!wanted || localName(child) === wanted)) {
+        result.push(child);
+      }
+      visit(child);
+    }
+  };
+  visit(node);
+  return result;
+}
+
+export function firstElement(node, wanted) {
+  return elements(node, wanted)[0];
+}
+
+export function attr(node, wanted) {
+  for (const item of Array.from(node?.attributes || [])) {
+    if (localName(item) === wanted) return item.value;
+  }
+  return undefined;
+}
+
+export function attrQName(node, wanted) {
+  return node?.getAttribute?.(wanted) || undefined;
+}
+
+export function setAttr(node, qualifiedName, value) {
+  node.setAttribute(qualifiedName, String(value));
+}
+
+export function textOf(node) {
+  return elements(node, "t")
+    .map((item) => item.textContent || "")
+    .join("")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function parentElement(node, wanted) {
+  let current = node?.parentNode;
+  while (current) {
+    if (current.nodeType === 1 && (!wanted || localName(current) === wanted)) {
+      return current;
+    }
+    current = current.parentNode;
+  }
+  return undefined;
+}
+
+export async function loadPptx(pptxPath) {
+  const bytes = await fs.readFile(pptxPath);
+  return JSZip.loadAsync(bytes, {
+    checkCRC32: true,
+    createFolders: true,
+  });
+}
+
+export async function xmlFrom(zip, partName) {
+  const entry = zip.file(partName);
+  if (!entry) throw new Error(`PPTX part is missing: ${partName}`);
+  return entry.async("string");
+}
+
+export function resolvePart(basePart, target) {
+  if (String(target).startsWith("/")) return String(target).slice(1);
+  return path.posix.normalize(
+    path.posix.join(path.posix.dirname(basePart), String(target)),
+  );
+}
+
+export function relationshipPart(partName) {
+  return path.posix.join(
+    path.posix.dirname(partName),
+    "_rels",
+    `${path.posix.basename(partName)}.rels`,
+  );
+}
+
+export async function relationships(zip, partName) {
+  const relPart = relationshipPart(partName);
+  const entry = zip.file(relPart);
+  if (!entry) return { partName: relPart, document: null, records: [] };
+  const document = parseXml(await entry.async("string"));
+  const records = elements(document, "Relationship").map((node) => ({
+    node,
+    id: attr(node, "Id"),
+    type: attr(node, "Type"),
+    target: attr(node, "Target"),
+    targetMode: attr(node, "TargetMode"),
+    resolved:
+      attr(node, "TargetMode") === "External"
+        ? undefined
+        : resolvePart(partName, attr(node, "Target")),
+  }));
+  return { partName: relPart, document, records };
+}
+
+export async function slideRecords(zip) {
+  const presentationPart = "ppt/presentation.xml";
+  const presentationXml = await xmlFrom(zip, presentationPart);
+  const presentation = parseXml(presentationXml);
+  const presentationRels = await relationships(zip, presentationPart);
+  const byId = new Map(
+    presentationRels.records.map((record) => [record.id, record]),
+  );
+  const slides = [];
+  for (const [index, node] of elements(presentation, "sldId").entries()) {
+    const relationshipId =
+      attrQName(node, "r:id") ||
+      Array.from(node?.attributes || [])
+        .filter((item) => item.prefix === "r")
+        .map((item) => item.value)[0];
+    const relationship = byId.get(relationshipId);
+    if (!relationship?.resolved) continue;
+    slides.push({
+      slideNumber: index + 1,
+      slideId: Number(attrQName(node, "id") || attr(node, "id") || 0),
+      relationshipId,
+      partName: relationship.resolved,
+      relationship,
+    });
+  }
+  return {
+    presentationPart,
+    presentation,
+    presentationRels,
+    slides,
+  };
+}
+
+export function emuToPoints(value) {
+  return Number(value || 0) / 12700;
+}
+
+export function shapeTransform(shape) {
+  const xfrm = elements(shape, "xfrm")[0];
+  const off = xfrm ? elements(xfrm, "off")[0] : undefined;
+  const ext = xfrm ? elements(xfrm, "ext")[0] : undefined;
+  return {
+    x: emuToPoints(attr(off, "x")),
+    y: emuToPoints(attr(off, "y")),
+    width: emuToPoints(attr(ext, "cx")),
+    height: emuToPoints(attr(ext, "cy")),
+  };
+}
+
+export function shapeRecords(slideDocument) {
+  const candidates = elements(slideDocument).filter((node) =>
+    ["sp", "pic", "graphicFrame"].includes(localName(node)),
+  );
+  return candidates
+    .map((shape) => {
+      const cNvPr = elements(shape, "cNvPr")[0];
+      if (!cNvPr) return null;
+      const placeholder = elements(shape, "ph")[0];
+      const blip = elements(shape, "blip")[0];
+      const chart = elements(shape, "chart")[0];
+      const table = elements(shape, "tbl")[0];
+      const text = textOf(shape);
+      const shapeProperties = elements(shape, "spPr")[0];
+      const solidFill = shapeProperties
+        ? elements(shapeProperties, "solidFill")[0]
+        : undefined;
+      const rgbNode = solidFill
+        ? elements(solidFill, "srgbClr")[0]
+        : undefined;
+      const schemeNode = solidFill
+        ? elements(solidFill, "schemeClr")[0]
+        : undefined;
+      const fontSizes = elements(shape, "rPr")
+        .map((node) => Number(attr(node, "sz") || 0) / 100)
+        .filter((value) => value > 0);
+      const kind =
+        localName(shape) === "pic"
+          ? "image"
+          : chart
+            ? "chart"
+            : table
+              ? "table"
+              : "text";
+      return {
+        node: shape,
+        id: attr(cNvPr, "id"),
+        name: attr(cNvPr, "name") || "",
+        description: attr(cNvPr, "descr") || "",
+        placeholderType: attr(placeholder, "type") || "",
+        kind,
+        text,
+        fontSize: fontSizes.length ? Math.max(...fontSizes) : 0,
+        fillColor:
+          attr(rgbNode, "val") ||
+          (attr(schemeNode, "val")
+            ? `scheme:${attr(schemeNode, "val")}`
+            : undefined),
+        bbox: shapeTransform(shape),
+        relationshipId:
+          attrQName(blip, "r:embed") ||
+          attrQName(chart, "r:id") ||
+          attr(blip, "embed") ||
+          undefined,
+      };
+    })
+    .filter(Boolean);
+}