@pollium/vyva-convert 0.0.0-stage → 0.1.0

package/dist/gotenberg.d.ts

@@ -0,0 +1,8 @@
+import { PdfEngine } from "./export/pdf.js";
+//#region src/gotenberg.d.ts
+export interface GotenbergOptions {
+  url: string;
+  timeoutMs?: number;
+}
+export declare const gotenberg: ({ url, timeoutMs }: GotenbergOptions) => PdfEngine;
+//#endregion

package/dist/gotenberg.js

@@ -0,0 +1,39 @@
+import { ConvertError } from "./errors.js";
+//#region src/gotenberg.ts
+const DEFAULT_TIMEOUT_MS = 6e4;
+const CONVERT_PATH = "/forms/chromium/convert/html";
+const inches = (value) => String(Number(value.toFixed(3)));
+const formOf = ({ html, files, footerHtml, page }) => {
+	const form = new FormData();
+	form.append("files", new Blob([html], { type: "text/html" }), "index.html");
+	for (const file of files) form.append("files", new Blob([new Uint8Array(file.data)], { type: file.contentType }), file.name);
+	if (footerHtml !== null) form.append("files", new Blob([footerHtml], { type: "text/html" }), "footer.html");
+	const { margins } = page;
+	const sizes = {
+		paperWidth: page.width,
+		paperHeight: page.height,
+		marginTop: margins.top,
+		marginBottom: margins.bottom,
+		marginLeft: margins.left,
+		marginRight: margins.right
+	};
+	for (const [field, value] of Object.entries(sizes)) form.append(field, inches(value));
+	form.append("printBackground", "true");
+	form.append("preferCssPageSize", "false");
+	form.append("waitDelay", "0.5s");
+	return form;
+};
+const gotenberg = ({ url, timeoutMs = DEFAULT_TIMEOUT_MS }) => async (job) => {
+	const endpoint = `${url.replace(/\/+$/, "")}${CONVERT_PATH}`;
+	const response = await fetch(endpoint, {
+		method: "POST",
+		body: formOf(job),
+		signal: AbortSignal.timeout(timeoutMs)
+	}).catch((error) => {
+		throw new ConvertError("pdf-failed", `Gotenberg at ${url} could not be reached`, { cause: error });
+	});
+	if (!response.ok) throw new ConvertError("pdf-failed", `Gotenberg answered ${response.status}: ${await response.text().catch(() => "")}`);
+	return new Uint8Array(await response.arrayBuffer());
+};
+//#endregion
+export { gotenberg };

package/dist/import/documents.d.ts

@@ -0,0 +1,12 @@
+import { SaveImage } from "./images.js";
+import { DocumentContent } from "@pollium/vyva-core/content";
+//#region src/import/documents.d.ts
+export interface ImportedDocument {
+  title: string;
+  content: DocumentContent;
+}
+export declare const importDocx: (buffer: Buffer, filename: string, saveImage: SaveImage) => Promise<ImportedDocument>;
+export declare const importMarkdown: (text: string, filename: string) => ImportedDocument;
+export declare const importPlainText: (text: string, filename: string) => ImportedDocument;
+export declare const importPdf: (buffer: Buffer, filename: string) => Promise<ImportedDocument>;
+//#endregion

package/dist/import/documents.js

@@ -0,0 +1,44 @@
+import { htmlToBlocks, paragraphsHtml, titleFrom } from "./html-to-blocks.js";
+import { imageSaver } from "./images.js";
+import { markdownToBlocks } from "@pollium/vyva-core/markdown-blocks";
+import { DEFAULT_DOCUMENT_DESIGN } from "@pollium/vyva-core/themes";
+import mammoth from "mammoth";
+import { extractText, getDocumentProxy } from "unpdf";
+//#region src/import/documents.ts
+const MAX_IMAGES = 60;
+const PAGE_BREAK = "<div data-type=\"page-break\"></div>";
+const documentOf = (blocks, filename) => ({
+	title: titleFrom(blocks, filename),
+	content: {
+		kind: "document",
+		design: DEFAULT_DOCUMENT_DESIGN,
+		blocks
+	}
+});
+const importDocx = async (buffer, filename, saveImage) => {
+	const save = imageSaver(saveImage, filename, MAX_IMAGES);
+	const failures = [];
+	const result = await mammoth.convertToHtml({ buffer }, { convertImage: mammoth.images.imgElement(async (image) => {
+		const data = await image.readAsBuffer();
+		const fileId = await save(data, image.contentType).catch((error) => {
+			failures.push(error);
+			return null;
+		});
+		return fileId === null ? { src: "" } : {
+			src: "",
+			"data-file-id": fileId,
+			alt: ""
+		};
+	}) });
+	if (failures.length > 0) throw failures[0];
+	return documentOf(htmlToBlocks(result.value), filename);
+};
+const importMarkdown = (text, filename) => documentOf(markdownToBlocks(text), filename);
+const importPlainText = (text, filename) => documentOf(htmlToBlocks(paragraphsHtml(text)), filename);
+const importPdf = async (buffer, filename) => {
+	const { text } = await extractText(await getDocumentProxy(new Uint8Array(buffer)), { mergePages: false });
+	const html = text.map((page) => paragraphsHtml(page)).filter((page) => page !== "").join(PAGE_BREAK);
+	return documentOf(htmlToBlocks(html), filename);
+};
+//#endregion
+export { importDocx, importMarkdown, importPdf, importPlainText };

package/dist/import/html-to-blocks.d.ts

@@ -0,0 +1,6 @@
+import { DocumentBlock } from "@pollium/vyva-core/content";
+//#region src/import/html-to-blocks.d.ts
+export declare const htmlToBlocks: (html: string) => DocumentBlock[];
+export declare const titleFrom: (blocks: DocumentBlock[], filename: string) => string;
+export declare const paragraphsHtml: (text: string) => string;
+//#endregion

package/dist/import/html-to-blocks.js

@@ -0,0 +1,58 @@
+import { cleanHtml } from "../clean-html.js";
+import { titleOf } from "./titles.js";
+import { newId } from "@pollium/vyva-core/ids";
+import { DomUtils, parseDocument } from "htmlparser2";
+//#region src/import/html-to-blocks.ts
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+	"p",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"ul",
+	"ol",
+	"table",
+	"pre",
+	"blockquote",
+	"hr",
+	"div",
+	"img"
+]);
+const HEADINGS = /* @__PURE__ */ new Set(["h5", "h6"]);
+const ENTITIES = {
+	"&": "&",
+	"&lt;": "<",
+	"&gt;": ">",
+	"&quot;": "\"",
+	"&#39;": "'"
+};
+const htmlToBlocks = (html) => {
+	const blocks = [];
+	let loose = [];
+	const push = (outer) => {
+		const cleaned = cleanHtml(outer);
+		if (cleaned !== "" && cleaned !== "<p></p>") blocks.push({
+			id: newId(),
+			html: cleaned
+		});
+	};
+	const flush = () => {
+		const inner = loose.map((node) => DomUtils.getOuterHTML(node)).join("").trim();
+		loose = [];
+		if (inner !== "") push(`<p>${inner}</p>`);
+	};
+	for (const node of parseDocument(html).children) if (DomUtils.isTag(node) && (BLOCK_TAGS.has(node.name) || HEADINGS.has(node.name))) {
+		flush();
+		push(HEADINGS.has(node.name) ? `<h4>${DomUtils.getInnerHTML(node)}</h4>` : DomUtils.getOuterHTML(node));
+	} else loose.push(node);
+	flush();
+	return blocks;
+};
+const titleFrom = (blocks, filename) => {
+	const heading = blocks.find((block) => /^<h[1-3]/.test(block.html));
+	const text = heading === void 0 ? "" : heading.html.replace(/<[^>]+>/g, "").replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => ENTITIES[entity] ?? entity);
+	return titleOf(text, filename);
+};
+const paragraphsHtml = (text) => text.replace(/\r\n?/g, "\n").split(/\n{2,}/).map((part) => part.trim()).filter((part) => part !== "").map((part) => `<p>${part.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\n/g, "<br>")}</p>`).join("");
+//#endregion
+export { htmlToBlocks, paragraphsHtml, titleFrom };

package/dist/import/images.d.ts

@@ -0,0 +1,10 @@
+//#region src/import/images.d.ts
+export interface NewImage {
+  name: string;
+  data: Uint8Array;
+  contentType: string;
+}
+export type SaveImage = (image: NewImage) => Promise<string | null>;
+export type ImageSaver = (data: Uint8Array, contentType: string) => Promise<string | null>;
+export declare const imageSaver: (saveImage: SaveImage, filename: string, limit: number) => ImageSaver;
+//#endregion

package/dist/import/images.js

@@ -0,0 +1,23 @@
+//#region src/import/images.ts
+const EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/gif": "gif",
+	"image/webp": "webp"
+};
+const imageSaver = (saveImage, filename, limit) => {
+	const base = filename.replace(/\.[a-z0-9]+$/i, "");
+	let taken = 0;
+	return async (data, contentType) => {
+		const extension = EXTENSIONS[contentType];
+		if (extension === void 0 || taken >= limit) return null;
+		taken += 1;
+		return saveImage({
+			name: `${base} (image ${taken}).${extension}`,
+			data,
+			contentType
+		});
+	};
+};
+//#endregion
+export { imageSaver };

package/dist/import/pptx-package.d.ts

@@ -0,0 +1,22 @@
+import { PackageFiles, Relations, XmlDocument, XmlElement } from "./pptx-xml.js";
+import Palette from "./pptx-theme.js";
+//#region src/import/pptx-package.d.ts
+export interface SlidePart {
+  root: XmlElement;
+  tree: XmlElement | undefined;
+  relations: Relations;
+  palette: Palette;
+}
+export interface SlideParts {
+  slide: SlidePart;
+  layout: SlidePart | null;
+  master: SlidePart | null;
+}
+export default class PptxPackage {
+  #private;
+  constructor(files: PackageFiles);
+  document(path: string): XmlDocument | undefined;
+  relationsOf(path: string): Relations;
+  parts(slidePath: string): SlideParts | null;
+}
+//#endregion

package/dist/import/pptx-package.js

@@ -0,0 +1,61 @@
+import { first, relatedPart, relationsOf, xml } from "./pptx-xml.js";
+import Palette, { colorMapOf, themeOf } from "./pptx-theme.js";
+import { DomUtils } from "htmlparser2";
+import { strFromU8 } from "fflate";
+//#region src/import/pptx-package.ts
+var PptxPackage = class {
+	#files;
+	#documents = /* @__PURE__ */ new Map();
+	#palettes = /* @__PURE__ */ new Map();
+	constructor(files) {
+		this.#files = files;
+	}
+	document(path) {
+		const known = this.#documents.get(path);
+		if (known !== void 0) return known;
+		const data = this.#files[path];
+		if (data === void 0) return void 0;
+		const document = xml(strFromU8(data));
+		this.#documents.set(path, document);
+		return document;
+	}
+	relationsOf(path) {
+		return relationsOf(this.#files, path);
+	}
+	parts(slidePath) {
+		const slideRelations = relationsOf(this.#files, slidePath);
+		const layoutPath = relatedPart(slideRelations, "slideLayout");
+		const layoutRelations = layoutPath === null ? {} : relationsOf(this.#files, layoutPath);
+		const masterPath = layoutPath === null ? null : relatedPart(layoutRelations, "slideMaster");
+		const palette = this.#palette(masterPath);
+		const slide = this.#part(slidePath, slideRelations, palette);
+		if (slide === null) return null;
+		return {
+			slide,
+			layout: layoutPath === null ? null : this.#part(layoutPath, layoutRelations, palette),
+			master: masterPath === null ? null : this.#part(masterPath, relationsOf(this.#files, masterPath), palette)
+		};
+	}
+	#part(path, relations, palette) {
+		const root = this.document(path)?.children.find((node) => DomUtils.isTag(node));
+		if (root === void 0) return null;
+		return {
+			root,
+			tree: first(root, "p:spTree"),
+			relations,
+			palette
+		};
+	}
+	#palette(masterPath) {
+		const key = masterPath ?? "";
+		const known = this.#palettes.get(key);
+		if (known !== void 0) return known;
+		const masterRoot = (masterPath === null ? void 0 : this.document(masterPath))?.children.find((node) => DomUtils.isTag(node));
+		const themePath = masterPath === null ? null : relatedPart(relationsOf(this.#files, masterPath), "theme");
+		const palette = new Palette(themeOf(themePath === null ? void 0 : this.document(themePath)), colorMapOf(masterRoot));
+		this.#palettes.set(key, palette);
+		return palette;
+	}
+};
+//#endregion
+export { PptxPackage as default };

package/dist/import/pptx-placeholders.d.ts

@@ -0,0 +1,11 @@
+import { XmlElement } from "./pptx-xml.js";
+import { SlidePart, SlideParts } from "./pptx-package.js";
+//#region src/import/pptx-placeholders.d.ts
+export declare const TITLE_TYPES: string[];
+export declare const isDefined: <T>(value: T | undefined) => value is T;
+export declare const placeholderChain: (shape: XmlElement, placeholder: XmlElement, parts: SlideParts) => XmlElement[];
+export declare const levelOf: (shape: XmlElement) => XmlElement | undefined;
+export declare const masterLevel: (parts: SlideParts, type: string | null) => XmlElement | undefined;
+export declare const bulletsByDefault: (levels: XmlElement[]) => boolean;
+export declare const decorOf: (parts: SlideParts) => SlidePart[];
+//#endregion

package/dist/import/pptx-placeholders.js

@@ -0,0 +1,44 @@
+import { all, attr, first, kid, kids } from "./pptx-xml.js";
+//#region src/import/pptx-placeholders.ts
+const TITLE_TYPES = ["title", "ctrTitle"];
+const MASTER_TYPES = {
+	ctrTitle: "title",
+	subTitle: "body",
+	obj: "body"
+};
+const isDefined = (value) => value !== void 0;
+const placeholderType = (shape) => attr(first(shape, "p:ph"), "type") ?? "body";
+const masterType = (type) => MASTER_TYPES[type] ?? type;
+const placeholdersOf = (part) => part?.tree === void 0 ? [] : all(part.tree, "p:sp").filter((shape) => first(shape, "p:ph") !== void 0);
+const placeholderChain = (shape, placeholder, parts) => {
+	const type = attr(placeholder, "type") ?? "body";
+	const idx = attr(placeholder, "idx");
+	const layoutShapes = placeholdersOf(parts.layout);
+	const inLayout = (idx === void 0 ? void 0 : layoutShapes.find((candidate) => attr(first(candidate, "p:ph"), "idx") === idx)) ?? layoutShapes.find((candidate) => placeholderType(candidate) === type);
+	const wanted = masterType(inLayout === void 0 ? type : placeholderType(inLayout));
+	return [
+		shape,
+		inLayout,
+		placeholdersOf(parts.master).find((candidate) => masterType(placeholderType(candidate)) === wanted)
+	].filter(isDefined);
+};
+const levelOf = (shape) => kid(kid(kid(shape, "p:txBody"), "a:lstStyle"), "a:lvl1pPr");
+const masterLevel = (parts, type) => {
+	if (type === null || parts.master === null) return void 0;
+	const style = TITLE_TYPES.includes(type) ? "p:titleStyle" : masterType(type) === "body" ? "p:bodyStyle" : "p:otherStyle";
+	return kid(first(parts.master.root, style), "a:lvl1pPr");
+};
+const bulletsByDefault = (levels) => {
+	for (const level of levels) {
+		if (kids(level, "a:buNone").length > 0) return false;
+		if (kids(level, "a:buChar").length > 0 || kids(level, "a:buAutoNum").length > 0) return true;
+	}
+	return false;
+};
+const showsMasterShapes = (part) => attr(part.root, "showMasterSp") !== "0";
+const decorOf = (parts) => {
+	if (!showsMasterShapes(parts.slide) || parts.layout === null) return [];
+	return parts.master !== null && showsMasterShapes(parts.layout) ? [parts.master, parts.layout] : [parts.layout];
+};
+//#endregion
+export { TITLE_TYPES, bulletsByDefault, decorOf, isDefined, levelOf, masterLevel, placeholderChain };

package/dist/import/pptx-slide.d.ts

@@ -0,0 +1,19 @@
+import { SlideParts } from "./pptx-package.js";
+import { DeckTheme, Slide } from "@pollium/vyva-core/content";
+//#region src/import/pptx-slide.d.ts
+export interface SlideReaderOptions {
+  scale: number;
+  fontScale: number;
+  theme: DeckTheme;
+  image: (path: string) => Promise<string | null>;
+}
+export interface ReadSlide {
+  slide: Slide;
+  title: string;
+}
+export default class SlideReader {
+  #private;
+  constructor(options: SlideReaderOptions);
+  read(parts: SlideParts): Promise<ReadSlide>;
+}
+//#endregion