@openpresentation/opf-render 0.7.0 → 0.8.1

package/dist/fonts.js

@@ -25,12 +25,20 @@ export function createFontRegistry(entries, options = {}) {
     try { font = create(data, entry.postscriptName); } catch (error) { throw new OPFFontError("invalid-font-data", error.message); }
     if (!font?.layout || !font.unitsPerEm) throw new OPFFontError("font-collection", "Select one font from a collection with postscriptName.");
     const family = validFamily(entry.family ?? font.familyName);
+    // OpenType groups Medium/SemiBold/ExtraBold under a preferred family, while
+    // retaining separate legacy families for four-style native font selectors.
+    // An explicit caller rename owns its namespace and must not add this alias.
+    const familyGroup = entry.family && entry.family.toLowerCase() !== font.familyName?.toLowerCase()
+      ? family : validFamily(font.getName?.('preferredFamily', 'en') ?? family);
+    const linking = font['OS/2']?.fsSelection ?? font.head?.macStyle;
+    const fontFace = linking && typeof linking.bold === 'boolean' && typeof linking.italic === 'boolean'
+      ? {family:validFamily(font.getName?.('fontFamily', 'en') ?? font.familyName ?? family),bold:linking.bold,italic:linking.italic} : undefined;
     const weight = entry.weight ?? 400;
     const italic = entry.italic ?? !!font.italicAngle;
     if (!Number.isInteger(weight) || weight < 1 || weight > 1000) throw new OPFFontError("invalid-font-weight", "Font weight must be between 1 and 1000.");
     const signature = String.fromCharCode(...data.subarray(0,4));
     const format = signature === "OTTO" ? "otf" : signature === "wOFF" ? "woff" : signature === "wOF2" ? "woff2" : "ttf";
-    return {family,weight,italic,font,data,format,license:entry.license,cache:new Map()};
+    return {family,familyGroup,fontFace,weight,italic,font,data,format,license:entry.license,cache:new Map()};
   });
   const duplicates = new Set();
   for (const face of faces) {
@@ -38,12 +46,18 @@ export function createFontRegistry(entries, options = {}) {
     if (duplicates.has(id)) throw new OPFFontError("duplicate-font-face", `Duplicate face: ${id}`);
     duplicates.add(id);
   }
+  const familySlots = new Map();
+  for (const face of faces) for (const family of new Set([face.family,face.familyGroup])) {
+    const id=key(family,face.weight,face.italic),previous=familySlots.get(id);
+    if(previous && previous!==face) throw new OPFFontError('ambiguous-font-face', `Multiple physical faces match '${family}' at weight ${face.weight}.`, {fontFamily:family,fontWeight:face.weight,italic:face.italic});
+    familySlots.set(id,face);
+  }
   const substitutions = new Map();
   const aliases = new Map(Object.entries(options.aliases ?? {}).map(([from,to])=>[validFamily(from).toLowerCase(),validFamily(to)]));
   const policy = options.substitutionPolicy ?? "none";
   if (!["none","metric","visual"].includes(policy)) throw new OPFFontError("invalid-font-policy", "substitutionPolicy must be none, metric, or visual.");
   if (options.fallbackFamily) validFamily(options.fallbackFamily);
-  const findFamily = family => faces.filter(face=>face.family.toLowerCase()===family.toLowerCase());
+  const findFamily = family => faces.filter(face=>face.family.toLowerCase()===family.toLowerCase() || face.familyGroup.toLowerCase()===family.toLowerCase());
   const resolve = style => {
     const requested = validFamily(style?.fontFamily);
     const weight = style.fontWeight ?? 400;
@@ -79,30 +93,50 @@ export function createFontRegistry(entries, options = {}) {
     matching.sort((a,b)=>Math.abs(a.weight-weight)-Math.abs(b.weight-weight) || a.weight-b.weight);
     const face = matching[0];
     if (face.weight!==weight && compatibility!=="generic") compatibility="visual";
-    const resolution={requestedFamily:requested,sourceFamily:family,resolvedFamily:face.family,requestedWeight:weight,resolvedWeight:face.weight,italic:face.italic,compatibility,...(style.path?{path:style.path}:{}),...(rule?{source:rule.source,note:rule.note}:{})};
+    const resolution={requestedFamily:requested,sourceFamily:family,resolvedFamily:face.family,requestedWeight:weight,resolvedWeight:face.weight,italic:face.italic,compatibility,...(face.fontFace?{fontFace:{...face.fontFace}}:{}),...(style.path?{path:style.path}:{}),...(rule?{source:rule.source,note:rule.note}:{})};
     if (face.family.toLowerCase()!==family.toLowerCase() || face.weight!==weight) substitutions.set(JSON.stringify([requested,weight,!!style.italic,style.path]),resolution);
     return {face,resolution};
   };
   const resolveFace = style => resolve(style).face;
-  const resolveStyle = style => { const face=resolveFace(style); return {...style,fontFamily:face.family,fontWeight:face.weight,italic:face.italic}; };
-  const measure = (text,size,style) => {
+  const resolveStyle = style => {
+    const face=resolveFace(style),resolved={...style,fontFamily:face.family,fontWeight:face.weight,italic:face.italic};
+    // Never carry a stale selection from a previously resolved style.
+    delete resolved.fontFace;
+    if(face.fontFace) resolved.fontFace={...face.fontFace};
+    return resolved;
+  };
+  const metrics = (text,size,style,includeOutline=false) => {
+    if (typeof text!=='string'||!Number.isFinite(size)||size<=0) throw new OPFFontError('invalid-text-measurement','Text measurement requires a string and a positive finite font size.');
     const face=resolveFace(style);
-    let width=face.cache.get(text);
-    if (width===undefined) {
+    let value=face.cache.get(text);
+    if (value===undefined) {
       if (options.strictGlyphs!==false) for(const character of text) {
         if (/\p{Default_Ignorable_Code_Point}/u.test(character)) continue;
         if (!face.font.hasGlyphForCodePoint(character.codePointAt(0))) throw new OPFFontError("missing-glyph", `Font '${face.family}' cannot display U+${character.codePointAt(0).toString(16).toUpperCase()}.`, {path:style.path,fontFamily:face.family,character});
       }
-      width=face.font.layout(text).positions.reduce((total,position)=>total+position.xAdvance,0)/face.font.unitsPerEm;
+    }
+    if(value===undefined||includeOutline&&!Object.hasOwn(value,'outline')) {
+      const run=face.font.layout(text);
+      value={width:run.positions.reduce((total,position)=>total+position.xAdvance,0)/face.font.unitsPerEm,...value};
+      if(includeOutline) {
+        const bounds=run.bbox,unit=face.font.unitsPerEm;
+        value.outline=[bounds.minX,bounds.minY,bounds.maxX,bounds.maxY].every(Number.isFinite)
+          ?{x:bounds.minX/unit,y:-bounds.maxY/unit,width:bounds.width/unit,height:bounds.height/unit}:null;
+      }
       if (text.length<=2048) {
-        if (face.cache.size>=512) face.cache.delete(face.cache.keys().next().value);
-        face.cache.set(text,width);
+        if (face.cache.size>=512&&!face.cache.has(text)) face.cache.delete(face.cache.keys().next().value);
+        face.cache.set(text,value);
       }
     }
-    return width*size;
+    return value;
+  };
+  const measure=(text,size,style)=>metrics(text,size,style).width*size;
+  const outlineBounds=(text,size,style)=>{
+    const bounds=metrics(text,size,style,true).outline;
+    return bounds===null?null:{x:bounds.x*size,y:bounds.y*size,width:bounds.width*size,height:bounds.height*size};
   };
   return {
-    textMeasurement: {measure,resolveStyle},
+    textMeasurement: {measure,resolveStyle,outlineBounds},
     resolveFont(style) { return resolve(style).resolution; },
     clearSubstitutions() { substitutions.clear(); },
     get substitutions() { return [...substitutions.values()]; },

package/dist/index.d.ts

@@ -31,12 +31,27 @@ export declare const engineDefaults: Readonly<{
   chartTypes: readonly ["stacked-column-3x", "stacked-area-3x", "line-with-markers-3x"];
 }>;
 
+export type RenderDiagnostic = LayoutDiagnostic | {
+  code: "unsupported-pattern" | "date-needs-value";
+  path: string;
+  message: string;
+} | {
+  code: "unresolved-asset";
+  path: string;
+  message: string;
+  reason: "missing-reference" | "missing-source" | "unsupported-source";
+  source?: string;
+  assetId?: string;
+  description: string;
+  placeholder: "label" | "icon";
+};
+
 export interface RenderSvgOptions {
   textMeasurement?: TextMeasurement;
   embeddedFonts?: EmbeddedFont[];
   strictAssets?: boolean;
   imageResolver?: (src: string | undefined, context: { asset: unknown; path: string }) => string | null | undefined;
-  onDiagnostic?: (diagnostic: LayoutDiagnostic) => void;
+  onDiagnostic?: (diagnostic: RenderDiagnostic) => void;
   slideIndex?: number;
   trace?: boolean;
   catalogs?: Record<string, { records?: unknown[] } | unknown[]>;

package/dist/raster.js

@@ -98,29 +98,17 @@ async function loadPdfLib() {
 
 async function bundledFontFiles() {
   if (!bundledFontFilesCache) {
-    bundledFontFilesCache = resolveBundledFontFiles();
+    bundledFontFilesCache = resolveBundledFontFiles().catch(error => {
+      bundledFontFilesCache = null;
+      throw error;
+    });
   }
   return bundledFontFilesCache;
 }
 
 async function resolveBundledFontFiles() {
-  try {
-    const { createRequire } = await import("node:module");
-    const path = await import("node:path");
-    const require = createRequire(import.meta.url);
-    const roboto = path.dirname(require.resolve("@expo-google-fonts/roboto/package.json"));
-    const robotoMono = path.dirname(require.resolve("@expo-google-fonts/roboto-mono/package.json"));
-    return [
-      path.join(roboto, "400Regular/Roboto_400Regular.ttf"),
-      path.join(roboto, "500Medium/Roboto_500Medium.ttf"),
-      path.join(roboto, "700Bold/Roboto_700Bold.ttf"),
-      path.join(roboto, "800ExtraBold/Roboto_800ExtraBold.ttf"),
-      path.join(robotoMono, "400Regular/RobotoMono_400Regular.ttf"),
-      path.join(robotoMono, "700Bold/RobotoMono_700Bold.ttf")
-    ];
-  } catch {
-    return [];
-  }
+  const {loadBundledFontRegistry} = await import('./fonts-node.js');
+  return (await loadBundledFontRegistry()).fontFiles;
 }
 
 function normalizeSvgList(value) {

package/dist/svg.d.ts

@@ -31,12 +31,29 @@ export declare const engineDefaults: Readonly<{
   chartTypes: readonly ["stacked-column-3x", "stacked-area-3x", "line-with-markers-3x"];
 }>;
 
+export type RenderDiagnostic = LayoutDiagnostic | {
+  code: "unsupported-pattern" | "date-needs-value";
+  path: string;
+  message: string;
+} | {
+  code: "unresolved-asset";
+  path: string;
+  message: string;
+  reason: "missing-reference" | "missing-source" | "unsupported-source";
+  source?: string;
+  assetId?: string;
+  description: string;
+  placeholder: "label" | "icon";
+};
+
 export interface RenderSvgOptions {
   textMeasurement?: TextMeasurement;
+  /** Unscaled reference-pixel clearance around supplied vector text outlines; default 1. */
+  textRasterPadding?: number;
   embeddedFonts?: EmbeddedFont[];
   strictAssets?: boolean;
   imageResolver?: (src: string | undefined, context: { asset: unknown; path: string }) => string | null | undefined;
-  onDiagnostic?: (diagnostic: LayoutDiagnostic) => void;
+  onDiagnostic?: (diagnostic: RenderDiagnostic) => void;
   slideIndex?: number;
   trace?: boolean;
   catalogs?: Record<string, { records?: unknown[] } | unknown[]>;