@quario/pdf 0.3.0 → 0.4.0

package/lib/fonts.js

@@ -1,223 +0,0 @@
-/**
- * The faces a render can draw with.
- *
- * Every face is embedded on the document before the walk starts, so resolving
- * a style to a face during layout is synchronous — pdf-lib's `embedFont` is
- * async, and the walk is not. Embedding the twelve base-14 faces up front
- * costs under 200 bytes in the output, which is cheaper than threading a
- * two-pass measure/draw split through the layout to embed only what is used.
- */
-import { StandardFonts } from "pdf-lib";
-
-// The three families the vocabulary names, four variants each, indexed by
-// `bold + 2 * italic` — the same ordering the schema's `bold`/`italic` flags
-// produce. Unknown family names fall back to sans, as SCHEMA.md specifies.
-let BASE = {
-  sans: [
-    StandardFonts.Helvetica,
-    StandardFonts.HelveticaBold,
-    StandardFonts.HelveticaOblique,
-    StandardFonts.HelveticaBoldOblique,
-  ],
-  serif: [
-    StandardFonts.TimesRoman,
-    StandardFonts.TimesRomanBold,
-    StandardFonts.TimesRomanItalic,
-    StandardFonts.TimesRomanBoldItalic,
-  ],
-  mono: [
-    StandardFonts.Courier,
-    StandardFonts.CourierBold,
-    StandardFonts.CourierOblique,
-    StandardFonts.CourierBoldOblique,
-  ],
-};
-
-/** @typedef {{ families: Record<string, any[]> }} Fonts */
-
-// Host-supplied TrueType families need a font parser, which is an optional
-// peer: base-14 reports install nothing extra. Loaded only when `fonts` is
-// passed, and a missing package is reported as what it is.
-/** @type {(doc: any) => Promise<void>} */
-let useFontkit = async (doc) => {
-  let fontkit;
-  try {
-    fontkit = (await import("@pdf-lib/fontkit")).default;
-  } catch {
-    throw Error("options.fonts: install @pdf-lib/fontkit to embed TrueType families");
-  }
-  doc.registerFontkit(fontkit);
-};
-
-/** @type {(doc: any) => Promise<Record<string, any[]>>} */
-let embedBase = async (doc) => {
-  /** @type {Record<string, any[]>} */
-  let families = {};
-  for (let [name, variants] of Object.entries(BASE))
-    families[name] = await Promise.all(variants.map((v) => doc.embedFont(v)));
-  return families;
-};
-
-/** @type {(name: string, def: any) => string} */
-let asFamily = (name, def) => {
-  let path = "options.fonts." + name;
-  if (!def || typeof def !== "object")
-    throw Error(path + ": expected { regular, bold?, italic?, boldItalic? }");
-  if (def.regular == null) throw Error(path + ".regular: required");
-  return path;
-};
-
-/** @type {(doc: any, src: any, path: string, variant: string) => Promise<any>} */
-let embedOne = async (doc, src, path, variant) => {
-  try {
-    return await doc.embedFont(src[variant], { subset: true });
-  } catch (e) {
-    throw Error(path + "." + variant + ": " + /** @type {Error} */ (e).message);
-  }
-};
-
-// Missing variants fall back to the family's regular, so a face is
-// always resolvable once the family is named.
-/** @type {(doc: any, src: any, path: string, variant: string, faces: any[]) => Promise<any>} */
-let embedVariant = async (doc, src, path, variant, faces) => {
-  if (src[variant] == null) return faces[0];
-  return embedOne(doc, src, path, variant);
-};
-
-/** @type {(doc: any, name: string, def: any) => Promise<any[]>} */
-let familyOf = async (doc, name, def) => {
-  let path = asFamily(name, def);
-  /** @type {any[]} */
-  let faces = [];
-  for (let variant of ["regular", "bold", "italic", "boldItalic"])
-    faces.push(await embedVariant(doc, def, path, variant, faces));
-  return faces;
-};
-
-/** @type {(doc: any, custom: any, families: Record<string, any[]>) => Promise<void>} */
-let embedCustom = async (doc, custom, families) => {
-  if (!(custom && Object.keys(custom).length)) return;
-  await useFontkit(doc);
-  for (let [name, def] of Object.entries(custom))
-    families[name.toLowerCase()] = await familyOf(doc, name, def);
-};
-
-/**
- * Embed every face the render can reach and return the registry `face()` reads.
- *
- * @param {any} doc The pdf-lib document.
- * @param {any} custom `options.fonts`, or null.
- * @returns {Promise<Fonts>}
- */
-export async function embedFonts(doc, custom) {
-  let families = await embedBase(doc);
-  await embedCustom(doc, custom, families);
-  return { families };
-}
-
-// What a declared `family` normalises to before it is looked up: lower case,
-// and nothing at all when the value is not a name. Exported because the report
-// default is normalised once per render rather than once per cell, and two
-// spellings of this would drift.
-/** @type {(style: any) => string} */
-export let familyName = (style) =>
-  typeof style.family === "string" ? style.family.toLowerCase() : "";
-
-// Own-key lookup: the family name is render data, so `constructor` must
-// fall back to sans rather than resolve an inherited member.
-/** @type {(fonts: Fonts, name: string | null) => any[]} */
-let variantsOf = (fonts, name) =>
-  name && Object.hasOwn(fonts.families, name) ? fonts.families[name] : fonts.families.sans;
-
-/** @type {(style: any) => number} */
-let faceIndex = (style) => (style.bold ? 1 : 0) | (style.italic ? 2 : 0);
-
-/**
- * Resolve a style block to one embedded face.
- *
- * `fallback` is the report default's family, which the canvas carries for the
- * whole render (docs/adr/0033) — so text declaring no family is set in the
- * document's.
- *
- * The fallback turns on whether a family was *declared*, never on whether the
- * declared one resolves: a literal `family` is a non-empty string by the time
- * the engine passes it, but an `=` expression is resolved at render and
- * reaches here unchecked, so an item can declare `""`, a number or `null`.
- * Those are the item's own declaration and fall to sans like any other name
- * this target cannot resolve (SCHEMA.md) — the document's family is for text
- * that declared none. Own-key, because the block is render data.
- *
- * @type {(fonts: Fonts, style: any, fallback: string | null) => any}
- */
-export function face(fonts, style, fallback) {
-  let declared = Object.hasOwn(style, "family");
-  return variantsOf(fonts, declared ? familyName(style) : fallback)[faceIndex(style)];
-}
-
-// The distance from a line's top to its baseline: pdf-lib's ascender, which
-// matches the per-family fractions the hand-rolled writer used.
-/** @type {(font: any, size: number) => number} */
-export let ascOf = (font, size) => font.heightAtSize(size, { descender: false });
-
-// Text measurement. pdf-lib encodes on draw, so nothing here needs to know
-// about WinAnsi or glyph ids.
-/** @type {(font: any, text: string, size: number) => number} */
-export let width = (font, text, size) => font.widthOfTextAtSize(text, size);
-
-// Printable ASCII, which every text face encodes and which almost all report
-// text is. Asking the cmap instead costs a set walk per atom.
-let ASCII = /^[\x20-\x7E]*$/;
-
-// pdf-lib's getCharacterSet() is the cmap for both kinds of face: WinAnsi
-// code points on the base-14, fontkit's characterSet on an embedded TTF.
-// widthOfTextAtSize does not throw on a TrueType .notdef, so the old probe
-// let cmap holes through as glyph id 0. A face with no cmap (the layout
-// suite's measuring doubles) does not substitute: width is its whole contract.
-let CHARSETS = new WeakMap();
-let OPEN = { has: () => true };
-
-/** @typedef {{ has: (code: number) => boolean }} Cmap */
-
-/** @type {(font: any) => Cmap} */
-let charsetOf = (font) => {
-  let set = CHARSETS.get(font);
-  if (set) return set;
-  set = typeof font.getCharacterSet === "function" ? new Set(font.getCharacterSet()) : OPEN;
-  CHARSETS.set(font, set);
-  return set;
-};
-
-/**
- * Replace characters a face cannot draw with `?`.
- *
- * Cell text is untrusted data, so one stray character must not fail the
- * render: SCHEMA.md promises `?` for any face — WinAnsi on the base-14, the
- * cmap on an embedded TrueType. A face that also lacks `?` omits the
- * character rather than drawing .notdef.
- *
- * The ASCII guard carries the common case; only text with a character
- * outside it pays for the cmap walk. Printable ASCII is a subset of WinAnsi
- * and of every text face this target embeds.
- *
- * @type {(font: any, text: string) => string}
- */
-export let printable = (font, text) => {
-  if (!text || ASCII.test(text) || encodable(font, text)) return text;
-  return replaceUndrawable(charsetOf(font), text);
-};
-
-/** @type {(set: Cmap, text: string) => string} */
-let replaceUndrawable = (set, text) => {
-  let sub = set.has(0x3f) ? "?" : "";
-  // Encodedness is a per-code-point question, so that is the unit to ask it
-  // in — the grapheme clusters the rule protects are undrawable anyway.
-  // oxlint-disable-next-line typescript/no-misused-spread
-  return [...text].map((char) => (set.has(char.codePointAt(0) ?? -1) ? char : sub)).join("");
-};
-
-/** @type {(font: any, text: string) => boolean} */
-let encodable = (font, text) => {
-  let set = charsetOf(font);
-  // oxlint-disable-next-line typescript/no-misused-spread
-  return [...text].every((char) => set.has(char.codePointAt(0) ?? -1));
-};

package/lib/image.js

@@ -1,58 +0,0 @@
-/**
- * An image's own size, read from its header. Sizing is a fact about the bytes
- * rather than anything a page can answer, so it sits here and not on the
- * drawing surface: the band flow asks for it while measuring, where no
- * document is in reach at all, and again while drawing, where one is.
- *
- * Read, never decoded — a PNG's IHDR and a JPEG's frame header carry the two
- * numbers this target needs, and nothing else here looks at a pixel.
- *
- * The XLSX target reads the same two headers for its own placement, in pixels.
- * Whether that fact belongs on the engine's event instead — it already reads
- * the magic numbers to name the format — is bead `quario-b0h`.
- */
-
-// Points, at the conventional 96 dpi the schema names: 72/96 of a pixel.
-let PER_PX = 72 / 96;
-
-/** @type {(bytes: Uint8Array, at: number) => number} */
-let word = (bytes, at) => (bytes[at] << 8) | bytes[at + 1];
-
-/** @type {(code: number) => boolean} */
-let inSof = (code) => code >= 0xc0 && code <= 0xcf;
-
-/** @type {(code: number) => boolean} */
-let notTable = (code) => code !== 0xc4 && code !== 0xc8 && code !== 0xcc;
-
-// The frame header carries the dimensions, and it is the first SOFn marker:
-// every code in C0..CF except the three in that range that are not frames --
-// DHT, the JPG extension, and DAC.
-/** @type {(code: number) => boolean} */
-let isFrame = (code) => inSof(code) && notTable(code);
-
-/** @type {(bytes: Uint8Array) => { w: number, h: number }} */
-let jpegSize = (bytes) => {
-  for (let at = 2; at + 9 < bytes.length; at += 2 + word(bytes, at + 2)) {
-    if (bytes[at] !== 0xff) break;
-    if (isFrame(bytes[at + 1])) return { w: word(bytes, at + 7), h: word(bytes, at + 5) };
-  }
-  return { w: 0, h: 0 };
-};
-
-/**
- * The image's intrinsic size in points. The format is the engine's sniff,
- * riding on the event, so nothing here decides it a second time.
- *
- * @param {Uint8Array} bytes The image file.
- * @param {string} format The engine's sniff: `"png"` or `"jpeg"`.
- * @returns {{ w: number, h: number }} The size, in points.
- */
-export let intrinsic = (bytes, format) => {
-  // A PNG carries the two numbers in its IHDR at a fixed offset.
-  let { w, h } = format === "png" ? { w: word(bytes, 18), h: word(bytes, 22) } : jpegSize(bytes);
-  // The engine vouched for the magic numbers, not for the rest of the file:
-  // a truncated header reaches here as a zero, and failing loudly beats
-  // drawing an image with no size (SCHEMA.md, "Image item").
-  if (!(w > 0 && h > 0)) throw Error("image: could not read the image's size from its bytes");
-  return { w: w * PER_PX, h: h * PER_PX };
-};