pptx-glimpse 3.0.0 → 3.1.1

package/dist/chunk-3UFL5U77.js

@@ -0,0 +1,83 @@
+import {
+  DEFAULT_OUTPUT_WIDTH,
+  convertPptxToSvg,
+  renderPptxSourceModelToSvg
+} from "./chunk-AQ35JYTB.js";
+
+// src/converter.ts
+async function convertPptxToSvg2(input, options) {
+  return convertPptxToSvg(input, options, loadSystemFontSetup);
+}
+async function renderPptxSourceModelToSvg2(source, options) {
+  return renderPptxSourceModelToSvg(source, options, loadSystemFontSetup);
+}
+async function convertPptxToPng(input, options) {
+  const svgResult = await convertPptxToSvg2(input, {
+    ...options,
+    textOutput: "path"
+  });
+  const width = options?.width ?? DEFAULT_OUTPUT_WIDTH;
+  const height = options?.height;
+  const fontBuffers = await loadPngFontBuffers(options);
+  const slides = [];
+  for (const { slideNumber, svg } of svgResult.slides) {
+    const pngResult = await convertSvgToPng(svg, { width, height, fontBuffers });
+    slides.push({
+      slideNumber,
+      png: toPlainUint8Array(pngResult.png),
+      width: pngResult.width,
+      height: pngResult.height
+    });
+  }
+  return {
+    slides,
+    diagnostics: svgResult.diagnostics,
+    supportCoverage: svgResult.supportCoverage
+  };
+}
+var loadSystemFontSetup = async (options) => {
+  if (!shouldLoadSystemFonts(options)) {
+    return null;
+  }
+  const { createOpentypeSetupFromSystem } = await import(
+    /* @vite-ignore */
+    "./node-E6UXPQSQ.js"
+  );
+  return createOpentypeSetupFromSystem(
+    options?.fontDirs,
+    options?.fontMapping,
+    options?.skipSystemFonts
+  );
+};
+async function loadPngFontBuffers(options) {
+  if (options?.fonts !== void 0) {
+    return options.fonts.map((font) => toUint8Array(font.data));
+  }
+  if (!shouldLoadSystemFonts(options)) {
+    return [];
+  }
+  const { loadFontBuffersFromSystem } = await import(
+    /* @vite-ignore */
+    "./node-font-loader-OE3OLNDI.js"
+  );
+  return loadFontBuffersFromSystem(options?.fontDirs, options?.skipSystemFonts);
+}
+async function convertSvgToPng(svg, options) {
+  const { svgToPng } = await import("./png-IONMVVDQ.js");
+  return svgToPng(svg, options);
+}
+function shouldLoadSystemFonts(options) {
+  return options?.skipSystemFonts !== true || (options?.fontDirs?.length ?? 0) > 0;
+}
+function toUint8Array(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function toPlainUint8Array(data) {
+  return new Uint8Array(data);
+}
+
+export {
+  convertPptxToSvg2 as convertPptxToSvg,
+  renderPptxSourceModelToSvg2 as renderPptxSourceModelToSvg,
+  convertPptxToPng
+};

package/dist/chunk-5YFLSUKM.js

@@ -0,0 +1,141 @@
+import {
+  createComputedView,
+  readPptx
+} from "./chunk-AQ35JYTB.js";
+
+// src/font/font-collector.ts
+var DEFAULT_THEME_FONTS = {
+  majorLatin: "Calibri",
+  minorLatin: "Calibri"
+};
+function collectUsedFonts(input) {
+  const source = readPptx(input);
+  const defaultFontScheme = findDefaultThemeFontScheme(source);
+  const computed = createComputedView(source);
+  const fonts = /* @__PURE__ */ new Set();
+  collectThemeFonts(defaultFontScheme, fonts);
+  const visitedTemplateParts = /* @__PURE__ */ new Set();
+  for (const slide of computed.slides) {
+    const slideFontScheme = findThemeFontScheme(source, slide.themePartPath) ?? defaultFontScheme;
+    const templateElementsByPart = /* @__PURE__ */ new Map();
+    for (const element of slide.elements) {
+      if (element.sourceLayer === "slide") {
+        collectFontsFromElements([element], fonts, slideFontScheme);
+        continue;
+      }
+      const key = `${element.sourceLayer}:${element.sourcePartPath}`;
+      const elements = templateElementsByPart.get(key);
+      if (elements) {
+        elements.push(element);
+      } else {
+        templateElementsByPart.set(key, [element]);
+      }
+    }
+    for (const [key, elements] of templateElementsByPart) {
+      if (visitedTemplateParts.has(key)) continue;
+      visitedTemplateParts.add(key);
+      collectFontsFromElements(elements, fonts, slideFontScheme);
+    }
+  }
+  return {
+    theme: {
+      majorFont: defaultFontScheme.majorLatin,
+      minorFont: defaultFontScheme.minorLatin,
+      majorFontEa: defaultFontScheme.majorEastAsian ?? null,
+      minorFontEa: defaultFontScheme.minorEastAsian ?? null,
+      majorFontCs: defaultFontScheme.majorComplexScript ?? null,
+      minorFontCs: defaultFontScheme.minorComplexScript ?? null
+    },
+    fonts: [...fonts].sort()
+  };
+}
+function findDefaultThemeFontScheme(source) {
+  const firstThemePartPath = source.slideMasters.find(
+    (master) => master.themePartPath !== void 0
+  )?.themePartPath;
+  const scheme = findThemeFontScheme(source, firstThemePartPath) ?? source.themes[0]?.fontScheme;
+  return applyDefaultThemeFonts(scheme);
+}
+function findThemeFontScheme(source, themePartPath) {
+  if (themePartPath === void 0) return void 0;
+  const scheme = source.themes.find((theme) => theme.partPath === themePartPath)?.fontScheme;
+  return scheme !== void 0 ? applyDefaultThemeFonts(scheme) : void 0;
+}
+function applyDefaultThemeFonts(scheme) {
+  return {
+    ...DEFAULT_THEME_FONTS,
+    ...scheme
+  };
+}
+function collectThemeFonts(fontScheme, fonts) {
+  addFont(fonts, fontScheme.majorLatin, fontScheme);
+  addFont(fonts, fontScheme.minorLatin, fontScheme);
+  addFont(fonts, fontScheme.majorEastAsian, fontScheme);
+  addFont(fonts, fontScheme.minorEastAsian, fontScheme);
+  addFont(fonts, fontScheme.majorComplexScript, fontScheme);
+  addFont(fonts, fontScheme.minorComplexScript, fontScheme);
+  addFont(fonts, fontScheme.majorJapanese, fontScheme);
+  addFont(fonts, fontScheme.minorJapanese, fontScheme);
+}
+function collectFontsFromElements(elements, fonts, fontScheme) {
+  for (const el of elements) {
+    switch (el.kind) {
+      case "shape":
+        if (el.textBody) collectFontsFromTextBody(el.textBody, fonts, fontScheme);
+        break;
+      case "group":
+        collectFontsFromElements(el.children, fonts, fontScheme);
+        break;
+      case "table":
+        for (const row of el.table.rows) {
+          for (const cell of row.cells) {
+            if (cell.textBody) collectFontsFromTextBody(cell.textBody, fonts, fontScheme);
+          }
+        }
+        break;
+      case "connector":
+      case "image":
+      case "chart":
+      case "smartArt":
+      case "raw":
+        break;
+    }
+  }
+}
+function collectFontsFromTextBody(textBody, fonts, fontScheme) {
+  for (const para of textBody.paragraphs) {
+    addFont(fonts, para.properties?.bulletFont, fontScheme);
+    for (const run of para.runs) {
+      addFont(fonts, run.properties?.typeface, fontScheme);
+      addFont(fonts, run.properties?.typefaceEa, fontScheme);
+      addFont(fonts, run.properties?.typefaceCs, fontScheme);
+    }
+  }
+}
+function addFont(fonts, font, fontScheme) {
+  const resolved = resolveThemeFontAlias(font, fontScheme);
+  if (resolved) fonts.add(resolved);
+}
+function resolveThemeFontAlias(font, fontScheme) {
+  if (font === void 0) return void 0;
+  switch (font) {
+    case "+mj-lt":
+      return fontScheme.majorLatin;
+    case "+mn-lt":
+      return fontScheme.minorLatin;
+    case "+mj-ea":
+      return fontScheme.majorEastAsian ?? fontScheme.majorJapanese;
+    case "+mn-ea":
+      return fontScheme.minorEastAsian ?? fontScheme.minorJapanese;
+    case "+mj-cs":
+      return fontScheme.majorComplexScript;
+    case "+mn-cs":
+      return fontScheme.minorComplexScript;
+    default:
+      return font.startsWith("+mj-") || font.startsWith("+mn-") ? void 0 : font;
+  }
+}
+
+export {
+  collectUsedFonts
+};