pagyra-js 0.0.1

package/src/pdf/font/font-registry.ts

@@ -0,0 +1,263 @@
+import type { CSSFontFace, Run, StyleSheets } from "../types.js";
+import { PdfDocument, type PdfObjectRef } from "../primitives/pdf-document.js";
+import type { FontConfig, TtfFontMetrics } from "../../types/fonts.js";
+import { FontEmbedder } from "./embedder.js";
+import { computeWidths } from "./widths.js";
+import { log } from "../../logging/debug.js";
+import { needsUnicode } from "../../text/text.js";
+import { fontWeightCacheKey, normalizeFontWeight, isBoldFontWeight } from "../../css/font-weight.js";
+import { PdfFontRegistry as GlyphSubsetRegistry } from "../font-subset/font-registry.js";
+import type { PdfFontSubset } from "./font-subset.js";
+import type { GlyphRun } from "../../layout/text-run.js";
+import type { UnifiedFont } from "../../fonts/types.js";
+import type { EmbeddedFont } from "./embedder.js";
+import {
+  parseFontFaces,
+  selectFaceForWeight,
+  parseFamilyList,
+  isItalicStyle,
+  normalizeToken,
+  baseFontFromFace,
+} from "../../css/font-face-parser.js";
+import {
+  BASE_FONT_ALIASES,
+  GENERIC_FAMILIES,
+  BASE14_FALLBACKS,
+  BASE14_FAMILY_VARIANTS,
+  BASE14_VARIANT_LOOKUP,
+  detectBase14Family,
+  classifyBase14Variant,
+  type Base14Family,
+  type Base14Variant,
+} from "./font-config.js";
+import { applyWeightToBaseFont } from "./resolvers/weight-style-applicator.js";
+import { buildAliasedFamilyStack } from "./resolvers/family-resolver.js";
+import { resolveBaseFont } from "./resolvers/base-font-mapper.js";
+import { FontResourceManager } from "./managers/font-resource-manager.js";
+import { SubsetResourceManager, type SubsetFontResource } from "./managers/subset-resource-manager.js";
+
+const DEFAULT_STEM_V = 80;
+
+export type PdfFont = {
+  name: string;
+  baseName?: string;    // for Base14 (Helvetica, etc.)
+  isBase14: boolean;
+  // ... extend as needed
+};
+
+export function getBase14(family: "Helvetica" | "Times-Roman" | "Courier"): PdfFont {
+  return { isBase14: true, baseName: family, name: family };
+}
+
+// Note: getFontForText needs access to doc and config, so we'll modify the signature
+export function getFontForText(_requestedFamily: string, text: string, _doc: any, _config: any): PdfFont {
+  if (needsUnicode(text)) {
+    // For now, use a simplified approach - we'll assume NotoSans-Regular is available
+    // In a full implementation, you'd initialize the embedder properly
+    const fontName = "NotoSans-Regular";
+    log("font", "info", "font-path", { base14: false, family: fontName, encoding: "Identity-H" });
+    return { isBase14: false, name: fontName };
+  }
+  const f = getBase14("Helvetica"); // fallback
+  log("font", "info", "font-path", { base14: true, family: f.baseName, encoding: "WinAnsi" });
+  return f;
+}
+
+const DEFAULT_FONT = "Times New Roman"; // Use embedded TTF font instead of base14
+
+export interface FontResource {
+  readonly baseFont: string;
+  readonly resourceName: string;
+  readonly ref: PdfObjectRef;
+  readonly isBase14: boolean;
+  readonly metrics?: TtfFontMetrics;
+  readonly embedded?: EmbeddedFont;
+}
+
+
+
+export class FontRegistry {
+  private readonly facesByFamily = new Map<string, CSSFontFace[]>();
+  private readonly fontResourceManager: FontResourceManager;
+  private readonly subsetResourceManager: SubsetResourceManager;
+  private embedder: FontEmbedder | null = null;
+  private fontConfig: FontConfig | null = null;
+
+  constructor(private readonly doc: PdfDocument, stylesheets: StyleSheets) {
+    const { facesByFamily } = parseFontFaces(stylesheets);
+    this.facesByFamily = facesByFamily;
+    this.fontResourceManager = new FontResourceManager(doc);
+    this.subsetResourceManager = new SubsetResourceManager(doc);
+  }
+
+  async ensureFontResource(family: string | undefined, weight?: number, style?: string): Promise<FontResource> {
+    const normalizedWeight = normalizeFontWeight(weight);
+    const familyKey = this.makeFamilyKey(family, normalizedWeight, style);
+    const cached = this.fontResourceManager.getCached(familyKey);
+    if (cached) {
+      return cached;
+    }
+
+    if (this.embedder && this.fontConfig) {
+      const familyStack = buildAliasedFamilyStack(family, this.fontConfig?.defaultStack);
+      const embedded = this.embedder.ensureFont(familyStack, normalizedWeight, style);
+      if (embedded) {
+        const resource: FontResource = {
+          baseFont: embedded.baseFont,
+          resourceName: embedded.resourceName,
+          ref: embedded.ref,
+          isBase14: false,
+          metrics: embedded.metrics,
+          embedded,
+        };
+        this.fontResourceManager.setCached(familyKey, resource);
+        return resource;
+      }
+    }
+
+    const resolved = this.ensureStandardFontResource(family, normalizedWeight, style);
+    this.fontResourceManager.setCached(familyKey, resolved);
+    return resolved;
+  }
+
+  // New method to get embedder reference
+  getEmbedder(): FontEmbedder | null {
+    return this.embedder;
+  }
+
+  getDefaultFontStack(): string[] {
+    if (!this.fontConfig?.defaultStack || this.fontConfig.defaultStack.length === 0) {
+      return [];
+    }
+    return [...this.fontConfig.defaultStack];
+  }
+
+  ensureFontResourceSync(family: string | undefined, weight?: number, style?: string): FontResource {
+    const normalizedWeight = normalizeFontWeight(weight);
+    const familyKey = this.makeFamilyKey(family, normalizedWeight, style);
+    const cached = this.fontResourceManager.getCached(familyKey);
+    if (cached) {
+      return cached;
+    }
+
+    if (this.embedder && this.fontConfig) {
+      const familyStack = buildAliasedFamilyStack(family, this.fontConfig?.defaultStack);
+
+      // Note: embedder.ensureFont is synchronous in its implementation (it uses pre-loaded data)
+      // even though the interface might not explicitly say so, we know it returns EmbeddedFont | null immediately.
+      const embedded = this.embedder.ensureFont(familyStack, normalizedWeight, style);
+      if (embedded) {
+        const resource: FontResource = {
+          baseFont: embedded.baseFont,
+          resourceName: embedded.resourceName,
+          ref: embedded.ref,
+          isBase14: false,
+          metrics: embedded.metrics,
+          embedded,
+        };
+        this.fontResourceManager.setCached(familyKey, resource);
+        return resource;
+      }
+    }
+
+    const resolved = this.ensureStandardFontResource(family, normalizedWeight, style);
+    this.fontResourceManager.setCached(familyKey, resolved);
+    return resolved;
+  }
+
+  ensureSubsetForGlyphRun(glyphRun: GlyphRun, font: FontResource): SubsetFontResource {
+    return this.subsetResourceManager.ensureSubsetForGlyphRun(glyphRun, font);
+  }
+
+
+
+  private ensureStandardFontResource(family: string | undefined, weight: number, style?: string): FontResource {
+    const candidates = [...parseFamilyList(family), DEFAULT_FONT];
+    for (const candidate of candidates) {
+      const normalizedCandidate = normalizeToken(candidate);
+      if (!normalizedCandidate) {
+        continue;
+      }
+      const candidateKey = this.familyWeightKey(normalizedCandidate, weight, style);
+      const existing = this.fontResourceManager.getCached(candidateKey);
+      if (existing) {
+        this.fontResourceManager.setCached(this.makeFamilyKey(family, weight, style), existing);
+        return existing;
+      }
+      const baseFont = resolveBaseFont(normalizedCandidate, weight, style, this.embedder !== null, this.facesByFamily);
+      const resource = this.fontResourceManager.ensureBaseFontResource(baseFont);
+      this.fontResourceManager.setCached(candidateKey, resource);
+      this.fontResourceManager.setCached(this.makeFamilyKey(candidate, weight, style), resource);
+      if (family && candidate !== family) {
+        this.fontResourceManager.setCached(this.makeFamilyKey(family, weight, style), resource);
+      }
+      return resource;
+    }
+    const fallbackBase = applyWeightToBaseFont(DEFAULT_FONT, weight, style);
+    const fallback = this.fontResourceManager.ensureBaseFontResource(fallbackBase);
+    this.fontResourceManager.setCached(this.familyWeightKey("", weight, style), fallback);
+    return fallback;
+  }
+
+
+
+  private makeFamilyKey(family: string | undefined, weight: number, style?: string): string {
+    return this.familyWeightKey(normalizeToken(family), weight, style);
+  }
+
+  private familyWeightKey(normalizedFamily: string, weight: number, style?: string): string {
+    const familyToken = normalizedFamily && normalizedFamily.length > 0 ? normalizedFamily : "__default";
+    const styleToken = isItalicStyle(style) ? "_italic" : "";
+    return `${familyToken}@${fontWeightCacheKey(weight)}${styleToken}`;
+  }
+
+
+
+
+  async initializeEmbedder(fontConfig: FontConfig): Promise<void> {
+    this.fontConfig = fontConfig;
+    this.embedder = new FontEmbedder(fontConfig, this.doc);
+    await this.embedder.initialize();
+    log("font", "debug", "embedder initialized", { fontConfig });
+  }
+
+  setFontConfig(fontConfig: FontConfig): void {
+    this.fontConfig = fontConfig;
+    this.embedder = new FontEmbedder(fontConfig, this.doc);
+    log("font", "debug", "font config set", { fontConfig });
+  }
+}
+
+export function initFontSystem(doc: PdfDocument, stylesheets: StyleSheets): FontRegistry {
+  return new FontRegistry(doc, stylesheets);
+}
+
+export async function ensureFontSubset(registry: FontRegistry, run: Run): Promise<FontResource> {
+  const font = await registry.ensureFontResource(run.fontFamily, run.fontWeight, run.fontStyle);
+  // === diagnóstico cirúrgico: caminho de fonte ===
+  log("font", "info", "font-path", {
+    base14: font.isBase14 === true,
+    family: font.baseFont,
+    encoding: font.isBase14 ? "WinAnsi" : "Identity-H"
+  });
+  return font;
+}
+
+export function ensureFontSubsetSync(registry: FontRegistry, run: Run): FontResource {
+  const font = registry.ensureFontResourceSync(run.fontFamily, run.fontWeight, run.fontStyle);
+  // === diagnóstico cirúrgico: caminho de fonte ===
+  log("font", "info", "font-path", {
+    base14: font.isBase14 === true,
+    family: font.baseFont,
+    encoding: font.isBase14 ? "WinAnsi" : "Identity-H"
+  });
+  return font;
+}
+
+export function finalizeFontSubsets(_registry: FontRegistry): void {
+  // Actual font materialization happens during PdfDocument.finalize().
+}
+
+export function preflightFontsForPdfa(_registry: FontRegistry): void {
+  // Placeholder for PDF/A validations.
+}

package/src/pdf/font/font-subset.ts

@@ -0,0 +1,258 @@
+import type { FontMetrics, FontProgram } from "../../fonts/types.js";
+import { createToUnicodeCMapText } from "./to-unicode.js";
+
+/**
+ * Represents a subsetted font ready for PDF embedding.
+ */
+export interface PdfFontSubset {
+    name: string;
+    firstChar: number;
+    lastChar: number;
+    widths: number[];
+    toUnicodeCMap: string;
+    fontFile: Uint8Array;
+    encodeGlyph(gid: number): number;
+    /**
+     * Ordered glyph IDs included in this subset. The position in this array matches
+     * the width entries when using identity encoding.
+     */
+    glyphIds: number[];
+}
+
+/**
+ * Options for creating a PDF font subset.
+ */
+export interface PdfFontSubsetOptions {
+    baseName: string;
+    fontMetrics: FontMetrics;
+    fontProgram: FontProgram;
+    usedGlyphIds: Set<number>;
+    /**
+     * Controls how glyph IDs are mapped to PDF character codes.
+     * - "identity" keeps CIDs = glyph IDs (suitable for CIDToGIDMap /Identity).
+     * - "sequential" densely re-encodes glyphs starting at 0.
+     */
+    encoding?: "identity" | "sequential";
+}
+
+/**
+ * Creates a PDF font subset for TTF fonts.
+ */
+export function createPdfFontSubset(options: PdfFontSubsetOptions): PdfFontSubset {
+    const { baseName, fontMetrics, fontProgram, usedGlyphIds } = options;
+    const encoding = options.encoding ?? "identity";
+
+    const glyphIds = Array.from(usedGlyphIds).sort((a, b) => a - b);
+    if (!glyphIds.includes(0)) {
+        glyphIds.unshift(0);
+    }
+
+    const gidToCharCode = new Map<number, number>();
+
+    if (encoding === "identity") {
+        for (const gid of glyphIds) {
+            gidToCharCode.set(gid, gid);
+        }
+    } else {
+        for (let i = 0; i < glyphIds.length; i++) {
+            gidToCharCode.set(glyphIds[i], i);
+        }
+    }
+
+    const firstChar = encoding === "identity" ? Math.min(...glyphIds) : 0;
+    const lastChar = encoding === "identity" ? Math.max(...glyphIds) : glyphIds.length - 1;
+
+    const unitsPerEm = fontMetrics.metrics.unitsPerEm;
+    const widths: number[] = [];
+    if (encoding === "identity") {
+        for (const gid of glyphIds) {
+            const glyphMetric = fontMetrics.glyphMetrics.get(gid);
+            const advanceWidth = glyphMetric?.advanceWidth ?? 0;
+            const pdfWidth = Math.round((advanceWidth / unitsPerEm) * 1000);
+            widths.push(pdfWidth);
+        }
+    } else {
+        for (const gid of glyphIds) {
+            const glyphMetric = fontMetrics.glyphMetrics.get(gid);
+            const advanceWidth = glyphMetric?.advanceWidth ?? 0;
+            const pdfWidth = Math.round((advanceWidth / unitsPerEm) * 1000);
+            widths.push(pdfWidth);
+        }
+    }
+
+    const cmapEntries: { gid: number; unicode: number }[] = [];
+    const unicodeMap = fontMetrics.cmap.unicodeMap;
+
+    for (const gid of glyphIds) {
+        let unicode: number | undefined;
+        for (const [cp, mappedGid] of unicodeMap.entries()) {
+            if (mappedGid === gid) {
+                unicode = cp;
+                break;
+            }
+        }
+        if (unicode !== undefined) {
+            const cid = gidToCharCode.get(gid);
+            if (cid !== undefined) {
+                cmapEntries.push({ gid: cid, unicode });
+            }
+        }
+    }
+
+    const toUnicodeCMap = createToUnicodeCMapText(cmapEntries);
+    const fontFile = extractFontFile(fontProgram);
+
+    const encodeGlyph = (gid: number): number => {
+        const charCode = gidToCharCode.get(gid);
+        if (charCode === undefined) {
+            throw new Error(`Glyph ID ${gid} not found in subset`);
+        }
+        return charCode;
+    };
+
+    return {
+        name: `/${baseName}`,
+        firstChar,
+        lastChar,
+        widths,
+        toUnicodeCMap,
+        fontFile,
+        encodeGlyph,
+        glyphIds,
+    };
+}
+
+/**
+ * Extracts the font file from FontProgram.
+ * Builds a complete TTF with all available tables.
+ */
+function extractFontFile(fontProgram: FontProgram): Uint8Array {
+    if (fontProgram.getRawTableData) {
+        return buildTtfFromTables(fontProgram);
+    }
+
+    console.warn("Font subsetting not fully implemented; no raw table data available");
+    return new Uint8Array(0);
+}
+
+/**
+ * Builds a complete TTF file from available tables in FontProgram.
+ */
+function buildTtfFromTables(fontProgram: FontProgram): Uint8Array {
+    const tableTags = [
+        'head', 'hhea', 'maxp', 'OS/2', 'hmtx', 'cmap',
+        'loca', 'glyf', 'name', 'post', 'cvt ', 'fpgm', 'prep'
+    ];
+
+    const tables: Map<string, Uint8Array> = new Map();
+
+    for (const tag of tableTags) {
+        const data = fontProgram.getRawTableData!(tag);
+        if (data && data.length > 0) {
+            tables.set(tag, data);
+        }
+    }
+
+    if (tables.size === 0) {
+        console.warn("No TTF tables available for font subsetting");
+        return new Uint8Array(0);
+    }
+
+    const numTables = tables.size;
+    const searchRange = Math.pow(2, Math.floor(Math.log2(numTables))) * 16;
+    const entrySelector = Math.floor(Math.log2(numTables));
+    const rangeShift = numTables * 16 - searchRange;
+
+    const headerSize = 12;
+    const directorySize = numTables * 16;
+    let dataSize = 0;
+    for (const data of tables.values()) {
+        dataSize += data.length + (4 - (data.length % 4)) % 4;
+    }
+
+    const totalSize = headerSize + directorySize + dataSize;
+    const buffer = new ArrayBuffer(totalSize);
+    const view = new DataView(buffer);
+    const bytes = new Uint8Array(buffer);
+
+    view.setUint32(0, 0x00010000, false);
+    view.setUint16(4, numTables, false);
+    view.setUint16(6, searchRange, false);
+    view.setUint16(8, entrySelector, false);
+    view.setUint16(10, rangeShift, false);
+
+    let directoryOffset = 12;
+    let dataOffset = headerSize + directorySize;
+
+    for (const [tag, data] of tables) {
+        const tagBytes = new TextEncoder().encode(tag.padEnd(4));
+        bytes.set(tagBytes.slice(0, 4), directoryOffset);
+
+        const checksum = calculateTableChecksum(data);
+        view.setUint32(directoryOffset + 4, checksum, false);
+        view.setUint32(directoryOffset + 8, dataOffset, false);
+        view.setUint32(directoryOffset + 12, data.length, false);
+
+        bytes.set(data, dataOffset);
+
+        const paddedLength = data.length + (4 - (data.length % 4)) % 4;
+
+        directoryOffset += 16;
+        dataOffset += paddedLength;
+    }
+
+    updateHeadChecksum(bytes, view, tables);
+
+    return bytes;
+}
+
+/**
+ * Calculate TTF table checksum
+ */
+function calculateTableChecksum(data: Uint8Array): number {
+    let sum = 0;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const nLongs = Math.floor(data.length / 4);
+
+    for (let i = 0; i < nLongs; i++) {
+        sum = (sum + view.getUint32(i * 4, false)) >>> 0;
+    }
+
+    const remaining = data.length % 4;
+    if (remaining > 0) {
+        let last = 0;
+        for (let i = 0; i < remaining; i++) {
+            last = (last << 8) | data[nLongs * 4 + i];
+        }
+        last = last << ((4 - remaining) * 8);
+        sum = (sum + last) >>> 0;
+    }
+
+    return sum >>> 0;
+}
+
+/**
+ * Update the checkSumAdjustment field in the head table
+ */
+function updateHeadChecksum(bytes: Uint8Array, view: DataView, tables: Map<string, Uint8Array>): void {
+    const numTables = tables.size;
+    let headOffset = -1;
+
+    for (let i = 0; i < numTables; i++) {
+        const dirOffset = 12 + i * 16;
+        const tag = new TextDecoder().decode(bytes.slice(dirOffset, dirOffset + 4));
+        if (tag.trim() === 'head') {
+            headOffset = view.getUint32(dirOffset + 8, false);
+            break;
+        }
+    }
+
+    if (headOffset === -1) return;
+
+    view.setUint32(headOffset + 8, 0, false);
+
+    const fileChecksum = calculateTableChecksum(bytes);
+
+    const adjustment = (0xB1B0AFBA - fileChecksum) >>> 0;
+    view.setUint32(headOffset + 8, adjustment, false);
+}