@pollium/vyva-convert 0.0.0-stage → 0.2.0

package/dist/import/pptx.js

@@ -0,0 +1,126 @@
+import { ConvertError } from "../errors.js";
+import { titleOf } from "./titles.js";
+import { imageSaver } from "./images.js";
+import { all, attr, first, num, textOf } from "./pptx-xml.js";
+import { familyOf } from "./pptx-theme.js";
+import PptxPackage from "./pptx-package.js";
+import SlideReader from "./pptx-slide.js";
+import { DECK_SIZES } from "@pollium/vyva-core/content";
+import { unzipSync } from "fflate";
+import { posix } from "node:path";
+//#region src/import/pptx.ts
+const EMU_PER_INCH = 914400;
+const PX_PER_INCH = 144;
+const DEFAULT_WIDTH = 12192e3;
+const DEFAULT_HEIGHT = 6858e3;
+const MAX_SLIDES = 300;
+const MAX_IMAGES = 80;
+const MAX_UNZIPPED_BYTES = 125829120;
+const IMAGE_TYPES = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp"
+};
+const FORMATS = [
+	{
+		format: "16:9",
+		ratio: 16 / 9
+	},
+	{
+		format: "4:3",
+		ratio: 4 / 3
+	},
+	{
+		format: "1:1",
+		ratio: 1
+	},
+	{
+		format: "a4-landscape",
+		ratio: 1527 / 1080
+	},
+	{
+		format: "a4-portrait",
+		ratio: 1080 / 1527
+	}
+];
+const formatFor = (cx, cy) => {
+	const ratio = cx / Math.max(cy, 1);
+	return FORMATS.reduce((best, candidate) => Math.abs(candidate.ratio - ratio) < Math.abs(best.ratio - ratio) ? candidate : best).format;
+};
+const plainText = (html) => html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+const deckTitle = (titles, slides, filename) => {
+	const biggest = slides[0]?.elements.filter((element) => element.type === "text" && !element.isLocked).sort((a, b) => b.style.fontSize - a.style.fontSize)[0];
+	const title = titles.find((candidate) => candidate !== "") ?? (biggest === void 0 ? "" : plainText(biggest.html));
+	return titleOf(title, filename);
+};
+const dominantFont = (parts, themeFont) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const { slide } of parts) for (const run of all(slide.root, "a:r")) {
+		const typeface = attr(first(run, "a:latin"), "typeface");
+		const family = typeface === void 0 || typeface.startsWith("+") ? themeFont : familyOf(typeface);
+		if (family !== null) counts.set(family, (counts.get(family) ?? 0) + all(run, "a:t").map(textOf).join("").length);
+	}
+	return [...counts].sort((a, b) => b[1] - a[1])[0]?.[0] ?? themeFont;
+};
+const unzipped = (buffer) => {
+	let total = 0;
+	return unzipSync(buffer, { filter: (file) => {
+		total += file.originalSize;
+		if (total > MAX_UNZIPPED_BYTES) throw new ConvertError("too-large", `The presentation unzips to more than ${MAX_UNZIPPED_BYTES} bytes`);
+		return file.name.startsWith("ppt/") || file.name === "[Content_Types].xml" || file.name.startsWith("docProps/");
+	} });
+};
+const importPptx = async (buffer, filename, saveImage) => {
+	const files = unzipped(buffer);
+	const pptx = new PptxPackage(files);
+	const presentation = pptx.document("ppt/presentation.xml");
+	if (presentation === void 0) throw new ConvertError("unsupported", `${filename} has no presentation in it`);
+	const size = first(presentation, "p:sldSz");
+	const cx = num(attr(size, "cx"), DEFAULT_WIDTH);
+	const cy = num(attr(size, "cy"), DEFAULT_HEIGHT);
+	const format = formatFor(cx, cy);
+	const relations = pptx.relationsOf("ppt/presentation.xml");
+	const allParts = all(presentation, "p:sldId").map((slide) => relations[attr(slide, "r:id") ?? ""]?.target).filter((path) => path !== void 0).slice(0, MAX_SLIDES).map((path) => pptx.parts(path)).filter((parts) => parts !== null);
+	const themed = allParts[0]?.slide.palette.deckTheme();
+	if (themed === void 0) throw new ConvertError("empty", `${filename} has no slides`);
+	const theme = {
+		...themed,
+		font: dominantFont(allParts, themed.font)
+	};
+	const save = imageSaver(saveImage, filename, MAX_IMAGES);
+	const saved = /* @__PURE__ */ new Map();
+	const reader = new SlideReader({
+		scale: DECK_SIZES[format].width / cx,
+		fontScale: DECK_SIZES[format].width / (cx / EMU_PER_INCH * PX_PER_INCH),
+		theme,
+		image: (path) => {
+			const known = saved.get(path);
+			if (known !== void 0) return known;
+			const data = files[path];
+			const contentType = IMAGE_TYPES[posix.extname(path).slice(1).toLowerCase()];
+			const fileId = data === void 0 || contentType === void 0 ? Promise.resolve(null) : save(data, contentType);
+			saved.set(path, fileId);
+			return fileId;
+		}
+	});
+	const slides = [];
+	const titles = [];
+	for (const parts of allParts) {
+		const read = await reader.read(parts);
+		slides.push(read.slide);
+		titles.push(read.title);
+	}
+	return {
+		title: deckTitle(titles, slides, filename),
+		content: {
+			kind: "deck",
+			format,
+			theme,
+			slides
+		}
+	};
+};
+//#endregion
+export { importPptx };

package/dist/import/titles.d.ts

@@ -0,0 +1,3 @@
+//#region src/import/titles.d.ts
+export declare const titleOf: (text: string, filename: string) => string;
+//#endregion

package/dist/import/titles.js

@@ -0,0 +1,6 @@
+//#region src/import/titles.ts
+const MAX_TITLE = 200;
+const UNTITLED = "Untitled";
+const titleOf = (text, filename) => (text.trim() || filename.replace(/\.[a-z0-9]+$/i, "").replace(/[_-]+/g, " ").trim() || UNTITLED).slice(0, MAX_TITLE);
+//#endregion
+export { titleOf };

package/dist/import.d.ts

@@ -0,0 +1,16 @@
+import { SaveImage } from "./import/images.js";
+import { PdfSlides } from "./import/pdf-slides.js";
+import { Content } from "@pollium/vyva-core/content";
+//#region src/import.d.ts
+export declare const MAX_IMPORT_BYTES: number;
+export interface ImportOptions {
+  saveImage: SaveImage;
+  maxBytes?: number;
+  pdfSlides?: PdfSlides;
+}
+export interface ImportedContent {
+  title: string;
+  content: Content;
+}
+export declare const importFile: (data: Uint8Array, filename: string, options: ImportOptions) => Promise<ImportedContent>;
+//#endregion

package/dist/import.js

@@ -0,0 +1,68 @@
+import { ConvertError } from "./errors.js";
+import { importDocx, importMarkdown, importPdf, importPlainText } from "./import/documents.js";
+import { importPptx } from "./import/pptx.js";
+import { importPdfSlides, isLandscapePdf } from "./import/pdf-slides.js";
+import { unzipSync } from "fflate";
+//#region src/import.ts
+const MAX_IMPORT_BYTES = 26214400;
+const ZIP_SIGNATURE = 67324752;
+const PDF_SIGNATURE = "%PDF-";
+const TEXT_SAMPLE_BYTES = 65536;
+const BOM = /^/;
+const zipParts = (buffer) => {
+	if (buffer.length < 4 || buffer.readUInt32LE(0) !== ZIP_SIGNATURE) return null;
+	try {
+		const names = /* @__PURE__ */ new Set();
+		unzipSync(buffer, { filter: (file) => {
+			names.add(file.name);
+			return false;
+		} });
+		return names;
+	} catch {
+		return null;
+	}
+};
+const isUtf8Text = (buffer) => {
+	const sample = buffer.subarray(0, TEXT_SAMPLE_BYTES);
+	if (sample.includes(0)) return false;
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(sample);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const detect = (buffer, filename) => {
+	const parts = zipParts(buffer);
+	if (parts !== null) {
+		if (parts.has("word/document.xml")) return "docx";
+		return parts.has("ppt/presentation.xml") ? "pptx" : null;
+	}
+	if (buffer.subarray(0, 5).toString("latin1") === PDF_SIGNATURE) return "pdf";
+	if (!isUtf8Text(buffer)) return null;
+	const extension = filename.toLowerCase().split(".").at(-1) ?? "";
+	if (extension === "md" || extension === "markdown") return "markdown";
+	if (extension === "txt") return "text";
+	return null;
+};
+const convert = async (detected, buffer, filename, { saveImage, pdfSlides }) => {
+	if (detected === "docx") return importDocx(buffer, filename, saveImage);
+	if (detected === "pptx") return importPptx(buffer, filename, saveImage);
+	if (detected === "pdf") return pdfSlides !== void 0 && await isLandscapePdf(buffer) ? importPdfSlides(buffer, filename, saveImage, pdfSlides) : importPdf(buffer, filename);
+	const text = buffer.toString("utf8").replace(BOM, "");
+	return detected === "markdown" ? importMarkdown(text, filename) : importPlainText(text, filename);
+};
+const isEmpty = (content) => content.kind === "document" ? content.blocks.length === 0 : content.slides.length === 0;
+const importFile = async (data, filename, options) => {
+	const { maxBytes = MAX_IMPORT_BYTES } = options;
+	if (data.length > maxBytes) throw new ConvertError("too-large", `The file is larger than ${maxBytes} bytes`);
+	const buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+	const name = filename.replace(/[\\/]/g, "_").slice(-200);
+	const detected = detect(buffer, name);
+	if (detected === null) throw new ConvertError("unsupported", `${name} is not a file Vyva can import`);
+	const imported = await convert(detected, buffer, name, options);
+	if (isEmpty(imported.content)) throw new ConvertError("empty", `${name} has nothing to import`);
+	return imported;
+};
+//#endregion
+export { MAX_IMPORT_BYTES, importFile };

package/dist/libreoffice.d.ts

@@ -0,0 +1,8 @@
+import { PdfSlides } from "./import/pdf-slides.js";
+//#region src/libreoffice.d.ts
+export interface LibreOfficeOptions {
+  command?: string;
+  timeoutMs?: number;
+}
+export declare const libreOffice: ({ command, timeoutMs }?: LibreOfficeOptions) => PdfSlides;
+//#endregion

package/dist/libreoffice.js

@@ -0,0 +1,39 @@
+import { ConvertError } from "./errors.js";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+//#region src/libreoffice.ts
+const DEFAULT_TIMEOUT_MS = 12e4;
+const run = promisify(execFile);
+const libreOffice = ({ command = "soffice", timeoutMs = DEFAULT_TIMEOUT_MS } = {}) => async (pdf) => {
+	const folder = await mkdtemp(join(tmpdir(), "vyva-slides-"));
+	const source = join(folder, "source.pdf");
+	try {
+		await writeFile(source, pdf);
+		await run(command, [
+			`-env:UserInstallation=${pathToFileURL(join(folder, "profile")).href}`,
+			"--headless",
+			"--infilter=impress_pdf_import",
+			"--convert-to",
+			"pptx",
+			"--outdir",
+			folder,
+			source
+		], { timeout: timeoutMs }).catch((error) => {
+			throw new ConvertError("slides-failed", `LibreOffice at ${command} could not turn the PDF into slides`, { cause: error });
+		});
+		return new Uint8Array(await readFile(join(folder, "source.pptx")).catch((error) => {
+			throw new ConvertError("slides-failed", "LibreOffice finished without writing the slides", { cause: error });
+		}));
+	} finally {
+		await rm(folder, {
+			recursive: true,
+			force: true
+		});
+	}
+};
+//#endregion
+export { libreOffice };

package/dist/text-measure.d.ts

@@ -0,0 +1,5 @@
+import { FontFamily, TextStyle } from "@pollium/vyva-core/content";
+//#region src/text-measure.d.ts
+export declare const textHeight: (html: string, style: TextStyle, font: FontFamily, width: number) => number;
+export declare const unwrappedWidth: (html: string, style: TextStyle, font: FontFamily) => number;
+//#endregion

package/dist/text-measure.js

@@ -0,0 +1,102 @@
+import { FONT_WIDTHS, MEASURED_CHARS } from "./font-widths.js";
+import { CODE_FONT } from "@pollium/vyva-core/code";
+//#region src/text-measure.ts
+const EM = 1e3;
+const BLOCK_GAP_EMS = .35;
+const LIST_INDENT_EMS = 1.15;
+const WIDTH_SAFETY = .97;
+const BLOCK_END = /<\/(?:p|li|h[1-6])>/i;
+const TAG = /<(\/?)([a-z0-9]+)[^>]*>|([^<]+)/gi;
+const BOLD_TAGS = /* @__PURE__ */ new Set([
+	"strong",
+	"b",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6"
+]);
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	nbsp: " ",
+	"#39": "'"
+};
+const INDEX = new Map([...MEASURED_CHARS].map((char, index) => [char, index]));
+const FALLBACK = INDEX.get("n") ?? 0;
+const decoded = (text) => text.replace(/&(#?\w+);/g, (entity, name) => ENTITIES[name] ?? (name.startsWith("#") ? String.fromCodePoint(Number(name.slice(1))) : entity));
+const glyphsOf = (html, font, isBold) => {
+	const glyphs = [];
+	let bold = 0;
+	let code = 0;
+	for (const [, closing, tag, text] of html.matchAll(TAG)) {
+		if (text !== void 0) {
+			for (const char of decoded(text).replace(/\s+/g, " ")) glyphs.push({
+				char,
+				font: code > 0 ? CODE_FONT : font,
+				isBold: isBold || bold > 0
+			});
+			continue;
+		}
+		const step = closing === "/" ? -1 : 1;
+		const name = tag.toLowerCase();
+		if (BOLD_TAGS.has(name)) bold = Math.max(0, bold + step);
+		else if (name === "code") code = Math.max(0, code + step);
+	}
+	return glyphs;
+};
+const blocksOf = (html, font, isBold) => html.split(BLOCK_END).flatMap((chunk) => {
+	const glyphs = glyphsOf(chunk, font, isBold);
+	while (glyphs[0]?.char === " ") glyphs.shift();
+	while (glyphs.at(-1)?.char === " ") glyphs.pop();
+	return glyphs.length === 0 ? [] : [{
+		glyphs,
+		isItem: /<li\b/i.test(chunk)
+	}];
+});
+const widthOf = (glyph, fontSize) => {
+	return FONT_WIDTHS[glyph.font][glyph.isBold ? "bold" : "regular"][INDEX.get(glyph.char) ?? FALLBACK] / EM * fontSize;
+};
+const linesOf = (glyphs, fontSize, width) => {
+	let lines = 1;
+	let line = 0;
+	let word = 0;
+	let space = 0;
+	const place = () => {
+		if (word > width) lines = Infinity;
+		if (line > 0 && line + space + word > width) {
+			lines += 1;
+			line = 0;
+		}
+		line += (line === 0 ? 0 : space) + word;
+		word = 0;
+	};
+	for (const glyph of glyphs) {
+		if (glyph.char !== " ") {
+			word += widthOf(glyph, fontSize);
+			continue;
+		}
+		place();
+		space = widthOf(glyph, fontSize);
+	}
+	place();
+	return lines;
+};
+const textHeight = (html, style, font, width) => {
+	const blocks = blocksOf(html, font, style.isBold);
+	return blocks.reduce((height, block, index) => {
+		const indent = block.isItem ? LIST_INDENT_EMS * style.fontSize : 0;
+		const gap = !block.isItem && index === blocks.length - 1 ? 0 : BLOCK_GAP_EMS * style.fontSize;
+		return height + linesOf(block.glyphs, style.fontSize, (width - indent) * WIDTH_SAFETY) * style.fontSize * style.lineHeight + gap;
+	}, 0);
+};
+const unwrappedWidth = (html, style, font) => {
+	const widths = blocksOf(html, font, style.isBold).map((block) => block.glyphs.reduce((width, glyph) => width + widthOf(glyph, style.fontSize), block.isItem ? LIST_INDENT_EMS * style.fontSize : 0));
+	return Math.ceil(Math.max(0, ...widths) / WIDTH_SAFETY) + 1;
+};
+//#endregion
+export { textHeight, unwrappedWidth };

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@pollium/vyva-convert",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "Server-side tools for Vyva content: clean what clients send, import Word, PowerPoint, PDF and Markdown files, and export to PDF, Word, PowerPoint and HTML.",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Pollium/Vyva.git",
+    "directory": "packages/convert"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@fontsource-variable/inter": "^5.3.0",
+    "@fontsource-variable/jetbrains-mono": "^5.3.0",
+    "@fontsource-variable/lora": "^5.3.0",
+    "@fontsource-variable/merriweather": "^5.3.0",
+    "@fontsource-variable/montserrat": "^5.3.0",
+    "@fontsource-variable/open-sans": "^5.3.0",
+    "@fontsource-variable/playfair-display": "^5.3.0",
+    "@fontsource-variable/roboto": "^5.3.0",
+    "docx": "^9.9.0",
+    "fflate": "^0.8.3",
+    "htmlparser2": "^10.1.0",
+    "mammoth": "^1.13.0",
+    "pptxgenjs": "^4.0.1",
+    "sanitize-html": "^2.18.0",
+    "unpdf": "^1.8.1",
+    "@pollium/vyva-core": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.4",
+    "@types/sanitize-html": "^2.16.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "oxlint --deny-warnings",
+    "test": "vitest run",
+    "font-widths": "node scripts/font-widths.ts"
+  }
 }