@quario/pdf 0.1.0 → 0.3.0

package/lib/outline.js

@@ -49,26 +49,6 @@ let linkKids = (entry, refs, kids, n) => {
   entry.Count = n;
 };
 
-/** @type {(ctx: any, refs: any[], root: any, parent: number[], marks: any[], pageRefs: any[], i: number, mark: any) => void} */
-let writeEntry = (ctx, refs, root, parent, marks, pageRefs, i, mark) => {
-  let siblings = kidsOf(parent, parent[i]);
-  let index = siblings.indexOf(i);
-  let kids = kidsOf(parent, i);
-  let target = pageRefs[Math.min(mark.page, pageRefs.length - 1)];
-  /** @type {Record<string, any>} */
-  let entry = {
-    Title: PDFHexString.fromText(mark.title),
-    Parent: parentRef(parent, i, root, refs),
-    // `/XYZ <x> <y> null`: scroll to the mark's line, keep the zoom. The
-    // left edge is the mark's own column, so two instances sharing a y in
-    // two page columns are two distinct destinations.
-    Dest: [target, PDFName.of("XYZ"), PDFNumber.of(mark.x), PDFNumber.of(mark.y), null],
-  };
-  linkSiblings(entry, refs, siblings, index);
-  linkKids(entry, refs, kids, descendants(marks, i));
-  ctx.assign(refs[i], ctx.obj(entry));
-};
-
 /**
  * Attach an outline built from `marks` to the document.
  *
@@ -82,8 +62,24 @@ export function outline(doc, marks, pageRefs) {
   let parent = parents(marks);
   let refs = marks.map(() => ctx.nextRef());
   let root = ctx.nextRef();
-  for (let [i, mark] of marks.entries())
-    writeEntry(ctx, refs, root, parent, marks, pageRefs, i, mark);
+  for (let [i, mark] of marks.entries()) {
+    let siblings = kidsOf(parent, parent[i]);
+    let index = siblings.indexOf(i);
+    let kids = kidsOf(parent, i);
+    let target = pageRefs[Math.min(mark.page, pageRefs.length - 1)];
+    /** @type {Record<string, any>} */
+    let entry = {
+      Title: PDFHexString.fromText(mark.title),
+      Parent: parentRef(parent, i, root, refs),
+      // `/XYZ <x> <y> null`: scroll to the mark's line, keep the zoom. The
+      // left edge is the mark's own column, so two instances sharing a y in
+      // two page columns are two distinct destinations.
+      Dest: [target, PDFName.of("XYZ"), PDFNumber.of(mark.x), PDFNumber.of(mark.y), null],
+    };
+    linkSiblings(entry, refs, siblings, index);
+    linkKids(entry, refs, kids, descendants(marks, i));
+    ctx.assign(refs[i], ctx.obj(entry));
+  }
 
   let top = kidsOf(parent, -1);
   ctx.assign(

package/lib/style.js

@@ -4,13 +4,12 @@
  * render: a value of the wrong shape contributes nothing rather than reaching
  * the page.
  *
- * `finite`/`HEX` are restated per target on purpose: the coercions are each
- * target's own edge, never shared engine code.
+ * `HEX` is restated per target on purpose: the coercion is each target's own
+ * edge, never shared engine code. Finiteness is not one of those coercions —
+ * `Number.isFinite` never coerces, so this target asks it directly.
  */
 import { rgb } from "pdf-lib";
 
-/** @type {(value: any) => boolean} */
-let finite = (value) => typeof value === "number" && Number.isFinite(value);
 let HEX = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
 
 // Leading as a fraction of the font size, cell padding, the gap between a
@@ -51,17 +50,20 @@ let col = (value) => {
 };
 
 /** @type {(style: any, base: number) => number} */
-let sizeOf = (style, base) => (finite(style.size) && style.size > 0 ? style.size : base);
+let sizeOf = (style, base) => (Number.isFinite(style.size) && style.size > 0 ? style.size : base);
 
-// Style blocks layer outward-in: row under cell.
+// Style blocks layer outward-in: row under cell, split under slot. Those are
+// the two innermost of the four layers; the outer two reach a node without
+// being merged into it -- the band-role default through `roled` below, and the
+// report default through the canvas, as `layout.js`'s `adoptDefault` explains.
 /** @type {(under: any, over: any) => any} */
 let merge = (under, over) => (under ? (over ? { ...under, ...over } : under) : over || {});
 
-// Band-role omakase defaults — the outermost layer of that same stack, under
-// the author's own style, which therefore always wins. Only the headline
-// roles carry one; the XLSX target carries the same two, byte-identical, in
-// `packages/xlsx/lib/index.js`, and they move together (SCHEMA.md states the
-// pair for both). A target can only import public engine helpers, so there is
+// Band-role omakase defaults — the third of those four layers, over the report
+// default and under the author's own, which therefore always wins. Only the
+// headline roles carry one; the XLSX target carries the same two,
+// byte-identical, in `packages/xlsx/lib/index.js`, and they move together
+// (SCHEMA.md states the pair for both). A target can only import public engine helpers, so there is
 // nowhere to share this from and the two copies are synced by hand.
 //
 // `@quario/html` deliberately carries none of this, nor the leading, padding
@@ -81,4 +83,15 @@ let roled = (event) =>
     ? { ...event, style: merge(ROLES[event.role], event.style) }
     : event;
 
-export { BAND, BLACK, GUTTER, LEAD, PADX, PADY, col, merge, roled, shift, sizeOf };
+// Whether a resolved style asks for either text decoration -- one reading for
+// the wrapper that stamps it on a line and the canvas that draws it.
+/** @type {(style: any) => boolean} */
+let dressed = (style) => !!(style && (style.underline || style.strikethrough));
+
+// Whether a resolved style asks for capitals. This target has no
+// text-transform to defer to, so the reading is here beside the rest of the
+// vocabulary and `text.js` applies it before measuring.
+/** @type {(style: any) => boolean} */
+let upper = (style) => !!(style && style.uppercase);
+
+export { BAND, BLACK, GUTTER, LEAD, PADX, PADY, col, dressed, merge, roled, shift, sizeOf, upper };

package/lib/text.js

@@ -3,13 +3,19 @@
  * their resolved typography, and a greedy breaker turns those into lines. Pure
  * measurement against the font registry — nothing here touches the page.
  */
+import { display, format } from "quario";
 import { ascOf, face, printable, width } from "./fonts.js";
-import { LEAD, col, sizeOf } from "./style.js";
+import { LEAD, col, dressed, sizeOf, upper } from "./style.js";
 
-// What measuring needs and no more: the embedded faces to measure against
-// and the base size a style falls back to. A `Canvas` satisfies it, so
-// callers pass theirs straight in — but nothing here can touch a page.
-/** @typedef {{ fonts: import('./fonts.js').Fonts, base: number }} Metrics */
+// What measuring needs and no more: the embedded faces to measure against, and
+// the base size and family a style falls back to — the report default's two
+// declarations, which the canvas carries for the whole render. A `Canvas`
+// satisfies it, so callers pass theirs straight in — but nothing here can
+// touch a page.
+/**
+ * @typedef {{ fonts: import('./fonts.js').Fonts, base: number,
+ *   family: string | null, locale?: string, currency?: string, timeZone?: string }} Metrics
+ */
 
 /**
  * @typedef {{ text: string, font: any, size: number, color: any,
@@ -21,13 +27,21 @@ import { LEAD, col, sizeOf } from "./style.js";
  *   underline?: boolean, strikethrough?: boolean }} Line
  */
 
-/**
- * @typedef {{ cur: Atom[], w: number, lines: Line[], base: number,
- *   fonts: import('./fonts.js').Fonts }} Wrap
- */
+/** @typedef {{ cur: Atom[], w: number, lines: Line[], base: number }} Wrap */
 
-/** @type {(token: any) => string} */
-let rawOf = (token) => ("literal" in token ? token.literal : String(token.value ?? ""));
+/** @type {(token: any, style: any, metrics: Metrics) => string} */
+let rawOf = (token, style, metrics) => {
+  if ("literal" in token) return token.literal;
+  return format(token.value, style?.format, metrics) ?? display(token.value);
+};
+
+// This target has no text-transform to defer to, so `uppercase` is applied to
+// the string before it is measured -- the widths have to be the widths of what
+// is actually drawn. `toUpperCase` rather than `toLocaleUpperCase`: this
+// target's output is byte-reproducible, so the host's locale must not reach
+// the glyphs.
+/** @type {(text: string, style: any) => string} */
+let cased = (text, style) => (upper(style) ? text.toUpperCase() : text);
 
 /** @type {(font: any, line: string) => string[]} */
 let partsOf = (font, line) => printable(font, line).split(/( +)/).filter(Boolean);
@@ -48,20 +62,23 @@ let pushLine = (out, font, size, color, i, line) => {
 let look = (metrics, style) => {
   let resolved = style || {};
   return {
-    font: face(metrics.fonts, resolved),
+    font: face(metrics.fonts, resolved, metrics.family),
     size: sizeOf(resolved, metrics.base),
     color: col(resolved.color),
   };
 };
 
 // Flatten a cell's tokens to word/space atoms carrying the cell's resolved
-// typography — one face, size and colour for the whole cell.
+// typography — one face, size and colour for the whole cell. CR, LF, and
+// CRLF are one hard break each (SCHEMA.md, Cell values).
 /** @type {(metrics: Metrics, tokens: any[], style: any) => Atom[]} */
 let atoms = (metrics, tokens, style) => {
   let out = /** @type {Atom[]} */ ([]);
   let { font, size, color } = look(metrics, style);
   for (let token of tokens)
-    for (let [i, line] of rawOf(token).split("\n").entries())
+    for (let [i, line] of cased(rawOf(token, style, metrics), style)
+      .split(/\r\n|\r|\n/)
+      .entries())
       pushLine(out, font, size, color, i, line);
   return out;
 };
@@ -103,7 +120,9 @@ let growPiece = (run, atom) => {
 /** @type {(state: Wrap, run: Run) => void} */
 let finish = (state, run) => {
   if (!run.size) run.size = state.base;
-  if (!run.asc) run.asc = ascOf(face(state.fonts, {}), run.size);
+  // No `asc` fallback: a run with no atoms is a blank line, and an ascender
+  // only places pieces. `drawLine` loops over none and `decorateLine` skips a
+  // line with no width, so a measured one would be a face lookup nothing reads.
   state.lines.push({
     pieces: run.pieces,
     w: run.w,
@@ -207,11 +226,12 @@ let placeAtom = (state, atom, avail) => {
 
 // Greedy wrap against `avail`: spaces never start a line, an over-wide word
 // breaks by character, hard breaks always break. A cell's atoms share one
-// typography, so a line's atoms merge into a single draw piece.
-/** @type {(metrics: Metrics, list: Atom[], avail: number) => Line[]} */
-let wrap = (metrics, list, avail) => {
+// typography, so a line's atoms merge into a single draw piece. `size` is the
+// empty-run height — a blank item, a hard-break hole.
+/** @type {(metrics: Metrics, list: Atom[], avail: number, size: number) => Line[]} */
+let wrap = (metrics, list, avail, size) => {
   /** @type {Wrap} */
-  let state = { cur: [], w: 0, lines: [], base: metrics.base, fonts: metrics.fonts };
+  let state = { cur: [], w: 0, lines: [], base: size };
   for (let atom of list) placeAtom(state, atom, avail);
   emit(state);
   return state.lines;
@@ -225,9 +245,6 @@ let stamp = (line, underline, strikethrough) => {
   if (strikethrough) line.strikethrough = true;
 };
 
-/** @type {(style: any) => boolean} */
-let dressed = (style) => !!(style && (style.underline || style.strikethrough));
-
 /** @type {(lines: Line[], style: any) => Line[]} */
 let dress = (lines, style) => {
   if (!dressed(style)) return lines;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quario/pdf",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "The browserless, paginated PDF render target for quario — in the makings, not yet released",
   "homepage": "https://getquario.com",
   "license": "SEE LICENSE IN LICENSE",
@@ -42,13 +42,13 @@
     "@arethetypeswrong/cli": "^0.18.3",
     "@pdf-lib/fontkit": "^1.1.1",
     "@size-limit/preset-small-lib": "^13.0.3",
-    "quario": "^0.1.0",
+    "quario": "^0.3.0",
     "size-limit": "^13.0.3",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
     "@pdf-lib/fontkit": "^1.1.1",
-    "quario": "^0.1.0"
+    "quario": "^0.3.0"
   },
   "peerDependenciesMeta": {
     "@pdf-lib/fontkit": {
@@ -62,7 +62,7 @@
         "quario",
         "pdf-lib"
       ],
-      "limit": "9.2 kB"
+      "limit": "10.5 kB"
     }
   ],
   "engines": {