@vyaz/core 0.0.4 → 0.0.6

package/src/measure/FontMetricsProvider.ts

@@ -1,226 +0,0 @@
-/**
- * FontMetricsProvider.ts — isomorphic font metrics provider.
- *
- * Strategy (priority):
- *   1. fontkit (Node.js) — from registered buffer
- *      - 'browser' mode: font.hhea.ascent / font.hhea.descent
- *      - 'office'  mode:  font['OS/2'].usWinAscent / font['OS/2'].usWinDescent
- *   2. Canvas TextMetrics (browser)
- *   3. Fallback (fontSize * 0.85 / 0.15)
- *
- * Uses FontRegistry for font registration.
- */
-
-import type { FontMetrics, IFontMetricsProvider } from '../types/FontTypes.js';
-import { enableOfficeTextMeasure, disableOfficeTextMeasure, registerCanvasFont } from './canvas-polyfill.js';
-import { FontNotFoundError } from './FontNotFoundError.js';
-
-// ── Weight normalisation ─────────────────────────────────────────────────
-
-/**
- * Map named font weights to numeric strings.
- * Both directions work: 'bold' → '700', 700 → '700', '700' → '700'.
- */
-const WEIGHT_TO_NUM: Record<string, string> = {
-  thin: '100',
-  hairline: '100',
-  ultralight: '200',
-  extralight: '200',
-  light: '300',
-  normal: '400',
-  medium: '500',
-  semibold: '600',
-  demibold: '600',
-  bold: '700',
-  ultrabold: '800',
-  extrabold: '800',
-  heavy: '900',
-  black: '900',
-};
-
-/** Normalise weight to a numeric string ("400", "700", etc.). */
-function normaliseWeight(weight: string): string {
-  const lower = weight.toLowerCase();
-  const mapped = WEIGHT_TO_NUM[lower];
-  if (mapped) return mapped;
-  return weight; // already numeric or unrecognised — pass through
-}
-
-/** Cache key: "${family}_${weight}_${style}" with normalised weight. */
-function cacheKey(family: string, weight: string, style: string): string {
-  return `${family}_${normaliseWeight(weight)}_${style}`;
-}
-
-export class FontMetricsProvider implements IFontMetricsProvider {
-  private cache = new Map<string, any>();   // fontkit.Font | undefined
-  private metricsCache = new Map<string, FontMetrics>();
-  private mode: 'browser' | 'office' = 'browser';
-
-  // ── Mode ──────────────────────────────────────────────────────────
-
-  setMode(mode: 'browser' | 'office'): void {
-    if (this.mode === mode) return;
-    this.mode = mode;
-    // Invalidate metrics cache on mode change
-    this.metricsCache.clear();
-
-    // Toggle ctx.measureText for pretext (canvas-based line breaking)
-    if (mode === 'office') {
-      enableOfficeTextMeasure(this.cache); // fontkit-based hmtx advance widths
-    } else {
-      disableOfficeTextMeasure(); // original Canvas 2D measureText
-    }
-  }
-
-  getMode(): 'browser' | 'office' {
-    return this.mode;
-  }
-
-  // ── FontRegistry ──────────────────────────────────────────────────
-
-  /**
-   * Register a binary font for use with fontkit.
-   * In browser — no-op (fonts are registered via CSS @font-face).
-   *
-   * @param sourcePath — if provided, also registers with @napi-rs/canvas for Node.js canvas measureText
-   */
-  async registerFont(
-    family: string,
-    options: { weight?: string; style?: string },
-    source: string | Buffer,
-    sourcePath?: string,
-  ): Promise<void> {
-    try {
-      // Dynamic ESM import — fontkit may not be available in browser
-      const fontkit = await import('fontkit');
-      const buffer = typeof source === 'string' ? Buffer.from(source) : source;
-      // @ts-ignore fontkit CJS/ESM compatibility
-      const fk = fontkit.default || fontkit;
-      const font = fk.create(buffer);
-      const key = cacheKey(
-        family,
-        options.weight || 'normal',
-        options.style || 'normal',
-      );
-      this.cache.set(key, font);
-      // Invalidate metrics for this font
-      this.metricsCache.delete(key);
-
-      // Also register with @napi-rs/canvas so ctx.measureText() uses real fonts
-      if (sourcePath) {
-        registerCanvasFont(sourcePath, family);
-      }
-    } catch {
-      // fontkit not available (browser) — no-op
-    }
-    return Promise.resolve();
-  }
-
-  // ── Font object access (for per-glyph advance) ────────────────────
-
-  /**
-   * Get fontkit font object for per-character calculations.
-   * Returns undefined if font is not registered or fontkit unavailable.
-   */
-  getFont(family: string, weight = 'normal', style = 'normal'): any | undefined {
-    const key = cacheKey(family, weight, style);
-    return this.cache.get(key);
-  }
-
-  // ── Metrics retrieval ─────────────────────────────────────────────
-
-  getMetrics(
-    fontFamily: string,
-    fontSize: number,
-    weight = 'normal',
-    style = 'normal',
-  ): FontMetrics {
-    const key = cacheKey(fontFamily, weight, style);
-
-    // Metrics cache (depends on fontSize, so include in key)
-    const metricsKey = `${key}_${fontSize}_${this.mode}`;
-    const cached = this.metricsCache.get(metricsKey);
-    if (cached) return cached;
-
-    let metrics: FontMetrics;
-
-    // Strategy 1: fontkit
-    const font = this.cache.get(key);
-
-    if (font) {
-      const scale = fontSize / font.unitsPerEm;
-
-      if (this.mode === 'office') {
-        // Office mode: OS/2.usWinAscent + usWinDescent
-        const os2 = font['OS/2'];
-        let ascent: number;
-        let descent: number;
-        let sourceTable: 'OS/2' | 'hhea';
-
-        if (os2 && os2.winAscent != null && os2.winDescent != null) {
-          ascent = os2.winAscent * scale  * 1.078;
-          descent = Math.abs(os2.winDescent) * scale * 1.078;
-          sourceTable = 'OS/2';
-        } else {
-          // Fallback to hhea if OS/2 is absent
-          ascent = font.ascent * scale;
-          descent = Math.abs(font.descent) * scale;
-          sourceTable = 'hhea';
-        }
-
-        metrics = {
-          ascent,
-          descent,
-          capHeight: (font.capHeight ?? ascent) * scale,
-          unitsPerEm: font.unitsPerEm,
-          sourceTable,
-        };
-      } else {
-        // Browser mode: hhea.ascender/descender
-        metrics = {
-          ascent: font.ascent * scale,
-          descent: Math.abs(font.descent) * scale,
-          capHeight: (font.capHeight ?? font.ascent) * scale,
-          unitsPerEm: font.unitsPerEm,
-          sourceTable: 'hhea',
-        };
-      }
-
-      this.metricsCache.set(metricsKey, metrics);
-      return metrics;
-    }
-
-    // Strategy 2: If fontkit cache is non-empty, fontkit is available but font not found → throw
-    if (this.cache.size > 0) {
-      throw new FontNotFoundError(fontFamily, weight, style);
-    }
-
-    // Strategy 3: Canvas TextMetrics (browser, fallback when fontkit unavailable)
-    if (typeof document !== 'undefined') {
-      try {
-        const canvas = document.createElement('canvas');
-        const ctx = canvas.getContext('2d')!;
-        ctx.font = `${style} ${weight} ${fontSize}px ${fontFamily}`;
-        const m = ctx.measureText('M');
-
-        metrics = {
-          ascent: m.fontBoundingBoxAscent || fontSize * 0.85,
-          descent: m.fontBoundingBoxDescent || fontSize * 0.15,
-          capHeight: m.actualBoundingBoxAscent || fontSize * 0.7,
-          unitsPerEm: 1000,
-          sourceTable: 'canvas',
-        };
-        this.metricsCache.set(metricsKey, metrics);
-        return metrics;
-      } catch {
-        // Fall through to fallback
-      }
-    }
-
-    // Font not found — throw error with clear message
-    throw new FontNotFoundError(fontFamily, weight, style);
-  }
-}
-
-/** Singleton */
-export const fontMetricsProvider = new FontMetricsProvider();

package/src/measure/FontNotFoundError.ts

@@ -1,16 +0,0 @@
-/**
- * FontNotFoundError.ts — thrown when a requested font is not registered.
- */
-export class FontNotFoundError extends Error {
-  constructor(
-    family: string,
-    weight = 'normal',
-    style = 'normal',
-  ) {
-    super(
-      `Font not found: "${family}" (weight: ${weight}, style: ${style}). ` +
-      `Use SystemFontRegistry.scan() to register system fonts.`,
-    );
-    this.name = 'FontNotFoundError';
-  }
-}

package/src/measure/SystemFontRegistry.ts

@@ -1,151 +0,0 @@
-/**
- * SystemFontRegistry.ts — singleton that scans system fonts using `get-system-fonts`
- * and registers them in FontMetricsProvider for both fontkit and @napi-rs/canvas.
- *
- * Usage:
- *   import { systemFontRegistry } from './SystemFontRegistry.js';
- *   await systemFontRegistry.scan();
- *   console.log(systemFontRegistry.getRegisteredFamilies());
- *
- * ⚠️ Node.js built-in module imports are dynamic (lazy) to avoid
- * Vite/Webpack externalization errors in browser builds.
- */
-
-import { fontMetricsProvider } from './FontMetricsProvider.js';
-
-interface ScanResult {
-  /** Total font files found on the system */
-  total: number;
-  /** Number of successfully registered font files */
-  registered: number;
-}
-
-/**
- * Parse font subfamily name into weight/style.
- * Examples:
- *   "Regular"       → { weight: 'normal', style: 'normal' }
- *   "Bold"          → { weight: 'bold',   style: 'normal' }
- *   "Italic"        → { weight: 'normal', style: 'italic' }
- *   "Bold Italic"   → { weight: 'bold',   style: 'italic' }
- *   "Light"         → { weight: 'light',  style: 'normal' }
- *   "Medium"        → { weight: 'medium', style: 'normal' }
- *   "Semi Bold"     → { weight: 'semibold', style: 'normal' }
- *   "Black"         → { weight: 'black',   style: 'normal' }
- */
-function parseSubfamily(subfamily: string): { weight: string; style: string } {
-  const lower = subfamily.toLowerCase();
-
-  let style: string;
-  if (lower.includes('italic')) {
-    style = 'italic';
-  } else {
-    style = 'normal';
-  }
-
-  let weight: string;
-  if (lower.includes('thin') || lower.includes('hairline')) {
-    weight = 'thin';
-  } else if (lower.includes('extralight') || lower.includes('ultralight')) {
-    weight = 'extralight';
-  } else if (lower.includes('light')) {
-    weight = 'light';
-  } else if (lower.includes('semibold') || lower.includes('demibold')) {
-    weight = 'semibold';
-  } else if (lower.includes('bold') || lower.includes('heavy') || lower.includes('black')) {
-    weight = 'bold';
-  } else if (lower.includes('medium') || lower.includes('medium')) {
-    weight = 'medium';
-  } else {
-    weight = 'normal';
-  }
-
-  return { weight, style };
-}
-
-export class SystemFontRegistry {
-  private static _instance: SystemFontRegistry;
-
-  /** Map of registered family names → true */
-  private registered = new Map<string, true>();
-
-  private constructor() {}
-
-  static get instance(): SystemFontRegistry {
-    if (!SystemFontRegistry._instance) {
-      SystemFontRegistry._instance = new SystemFontRegistry();
-    }
-    return SystemFontRegistry._instance;
-  }
-
-  /**
-   * Scan the system for all fonts and register them in FontMetricsProvider.
-   *
-   * - Uses `get-system-fonts` to find all .ttf/.otf files
-   * - Opens each with fontkit to extract familyName/subfamilyName
-   * - Registers in fontMetricsProvider (fontkit buffer + canvas path)
-   *
-   * @returns stats about what was found and registered
-   */
-  async scan(): Promise<ScanResult> {
-    // Dynamic imports — hidden from bundler static analysis.
-    // Only resolves on Node.js.  No-op in browser.
-    const [{ readFileSync }, getSystemFontsModule] = await Promise.all([
-      // @ts-ignore — 'node:fs' is a Node.js built-in; not resolvable with moduleResolution:bundler.
-      import('node:fs'),
-      import('get-system-fonts') as any,
-    ]);
-    const getSystemFonts = (getSystemFontsModule.default || getSystemFontsModule) as (opts?: any) => Promise<string[]>;
-
-    const paths: string[] = await getSystemFonts();
-    let registered = 0;
-
-    for (const fontPath of paths) {
-      try {
-        const buffer = readFileSync(fontPath);
-
-        // Dynamic import — fontkit may not be available in browser
-        let fontkit: any;
-        try {
-          fontkit = await import('fontkit');
-          // @ts-ignore fontkit CJS/ESM compatibility
-          fontkit = fontkit.default || fontkit;
-        } catch {
-          // fontkit not available — skip font registration
-          continue;
-        }
-
-        const font = fontkit.create(buffer);
-        const family = font.familyName;
-        if (!family) continue;
-
-        const { weight, style } = parseSubfamily(font.subfamilyName || 'Regular');
-
-        await fontMetricsProvider.registerFont(family, { weight, style }, buffer, fontPath);
-        this.registered.set(family, true);
-        registered++;
-      } catch {
-        // Skip unreadable / invalid font files
-        continue;
-      }
-    }
-
-    return { total: paths.length, registered };
-  }
-
-  /**
-   * Check if a font family is registered.
-   */
-  isRegistered(family: string): boolean {
-    return this.registered.has(family);
-  }
-
-  /**
-   * Get list of all registered font families.
-   */
-  getRegisteredFamilies(): string[] {
-    return Array.from(this.registered.keys());
-  }
-}
-
-/** Singleton instance */
-export const systemFontRegistry = SystemFontRegistry.instance;

package/src/measure/canvas-polyfill.d.ts

@@ -1,6 +0,0 @@
-/**
- * Type declarations for @napi-rs/canvas used by canvas-polyfill.ts.
- */
-declare module '@napi-rs/canvas' {
-  export function createCanvas(width: number, height: number): any;
-}

package/src/measure/canvas-polyfill.ts

@@ -1,235 +0,0 @@
-/**
- * Canvas API polyfill for Bun/Node.js via @napi-rs/canvas.
- * Required by @chenglou/pretext in server environments (Bun/Node.js without DOM).
- *
- * Two levels of polyfill:
- *   1. globalThis.document.createElement('canvas') — pretext uses this
- *      inside prepare() to create a temporary Canvas and call measureText.
- *   2. OffscreenCanvas — for some libraries and early versions.
- *
- * Exports enableOfficeTextMeasure / disableOfficeTextMeasure —
- * ctx.measureText override for fontkit-based measurements in Office mode.
- *
- * ⚠️ All Node.js built-in module imports are dynamic (lazy) to avoid
- * Vite/Webpack externalization errors in browser builds.
- */
-
-// ── Lazy Node.js module loader ─────────────────────────────────────
-// Dynamic import('module') — hidden from bundler static analysis.
-// Only resolves on Node.js / Bun.  No-op in browser.
-// Use 'any' for process to avoid requiring @types/node in browser contexts.
-const _process: any = typeof globalThis !== 'undefined'
-  ? (globalThis as any).process
-  : undefined;
-
-let _require: ((id: string) => any) | null = null;
-let _createCanvas: ((w: number, h: number) => any) | null = null;
-
-async function _initNodeDeps(): Promise<void> {
-  try {
-    // @ts-ignore — 'module' is a Node.js built-in; not resolvable with moduleResolution:bundler.
-    // This dynamic import is guarded by a runtime check and never executes in browser.
-    const m: any = await import('module');
-    _require = m.createRequire(import.meta.url);
-    const canvas: any = _require!('@napi-rs/canvas');
-    _createCanvas = canvas.createCanvas;
-  } catch {
-    // Browser or server without @napi-rs/canvas
-    _createCanvas = null;
-  }
-}
-
-// ESM top-level await — guarded by runtime check so bundlers don't
-// attempt to resolve 'module' at compile time.
-if (_process && (_process.versions?.node || _process.versions?.bun)) {
-  await _initNodeDeps();
-}
-
-// ── Polyfill document.createElement('canvas') ────────────────────────────
-// Pretext internally calls document.createElement('canvas') during prepare(),
-// to create a temporary Canvas and obtain a 2d context for measureText.
-// Without this polyfill, prepare() crashes with "document is not defined" in Bun.
-
-function needsCanvasPolyfill(): boolean {
-  if (typeof globalThis.document === 'undefined') return true;
-  try {
-    const el = globalThis.document.createElement('canvas');
-    if (!el || typeof el.getContext !== 'function') return true;
-    return false;
-  } catch {
-    return true;
-  }
-}
-
-if (needsCanvasPolyfill()) {
-  (globalThis as any).document = {
-    createElement: (tag: string) => {
-      if (tag === 'canvas' && _createCanvas) return _createCanvas(1, 1);
-      // For other elements — empty stub
-      return {};
-    },
-  };
-}
-
-// ── Polyfill OffscreenCanvas ─────────────────────────────────────────────
-// @napi-rs/canvas does not provide OffscreenCanvas, so we create a shim.
-
-if (typeof globalThis.OffscreenCanvas === 'undefined' && _createCanvas) {
-  (globalThis as any).OffscreenCanvas = class OffscreenCanvasShim {
-    private _canvas: any;
-    private _w: number;
-    private _h: number;
-
-    constructor(width: number, height: number) {
-      this._w = width;
-      this._h = height;
-      this._canvas = _createCanvas!(width, height);
-    }
-
-    get width(): number { return this._w; }
-    set width(v: number) { this._w = v; this._canvas.width = v; }
-    get height(): number { return this._h; }
-    set height(v: number) { this._h = v; this._canvas.height = v; }
-
-    getContext(type: string, attrs?: any): any {
-      return this._canvas.getContext(type, attrs);
-    }
-
-    async convertToBlob({ type: _type }: { type?: string } = {}): Promise<Blob> {
-      // @napi-rs/canvas toBuffer always returns PNG buffer
-      const buffer = this._canvas.toBuffer('image/png');
-      return new Blob([buffer], { type: 'image/png' });
-    }
-  };
-}
-
-// ── Office measureText override ─────────────────────────────────────
-
-const originalMeasureText = (globalThis as any).CanvasRenderingContext2D
-  ?.prototype?.measureText as
-  | ((text: string) => TextMetrics)
-  | undefined;
-
-/** fontCache: Map<family_weight_style, fontkit.Font> */
-let officeFontCache: Map<string, any> | null = null;
-let officeEnabled = false;
-
-/**
- * Parse ctx.font string like "italic bold 16px Arial" → { family, size, weight }
- */
-function parseFont(fontStr: string): { family: string; size: number; weight: string } | null {
-  // "italic bold 16px Arial" or "bold 16px Inter" or "16px Arial"
-  const pxMatch = fontStr.match(/(\d+(?:\.\d+)?)px\s+(.+)/);
-  if (!pxMatch) return null;
-  const size = parseFloat(pxMatch[1]);
-  // Simplified: everything after px is the family
-  const family = pxMatch[2].trim();
-  // Parse weight from beginning
-  const weightMatch = fontStr.match(/\b(bold|italic|\d{3})\b/);
-  const weight = weightMatch ? (weightMatch[1] === 'bold' ? 'bold' : weightMatch[1]) : 'normal';
-  return { family, size, weight };
-}
-
-/** Cache key: "${family}_${weight}_normal" */
-function cacheKey(family: string, weight: string): string {
-  return `${family}_${weight}_normal`;
-}
-
-function officeMeasureText(this: any, text: string): TextMetrics {
-  if (!officeFontCache) {
-    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
-  }
-
-  const parsed = parseFont(this.font);
-  if (!parsed) {
-    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
-  }
-
-  const key = cacheKey(parsed.family, parsed.weight);
-  const font = officeFontCache.get(key);
-  if (!font) {
-    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
-  }
-
-  const scale = parsed.size / font.unitsPerEm;
-  let totalWidth = 0;
-
-  for (let i = 0; i < text.length; i++) {
-    const codePoint = text.codePointAt(i)!;
-    const glyph = font.glyphForCodePoint(codePoint);
-    if (glyph) {
-      totalWidth += glyph.advanceWidth * scale;
-    } else {
-      // Fallback for missing glyph: use original
-      if (originalMeasureText) {
-        return originalMeasureText.call(this, text);
-      }
-      totalWidth += parsed.size * 0.5; // rough estimate
-    }
-    // Skip surrogate pairs
-    if (codePoint > 0xffff) i++;
-  }
-
-  return createMetricsObject(totalWidth);
-}
-
-function createMetricsObject(width: number): TextMetrics {
-  return {
-    width,
-    actualBoundingBoxAscent: 0,
-    actualBoundingBoxDescent: 0,
-    fontBoundingBoxAscent: 0,
-    fontBoundingBoxDescent: 0,
-    actualBoundingBoxLeft: 0,
-    actualBoundingBoxRight: width,
-  } as unknown as TextMetrics;
-}
-
-function createEmptyMetrics(): TextMetrics {
-  return createMetricsObject(0);
-}
-
-/**
- * Register a font with @napi-rs/canvas so ctx.measureText() works in Node.js.
- * No-op in browser or when @napi-rs/canvas is not available.
- */
-export function registerCanvasFont(fontPath: string, family: string): void {
-  if (!_require) return; // @napi-rs/canvas not available
-  try {
-    const mod = _require('@napi-rs/canvas');
-    if (mod?.registerFont) {
-      mod.registerFont(fontPath, { family });
-    }
-  } catch {
-    // @napi-rs/canvas not available — no-op
-  }
-}
-
-/**
- * Enable Office measurement: replaces ctx.measureText with fontkit-based version.
- * @param fontCache — Map key->font from FontMetricsProvider
- */
-export function enableOfficeTextMeasure(fontCache: Map<string, any>): void {
-  if (officeEnabled) return;
-  officeFontCache = fontCache;
-  officeEnabled = true;
-
-  const CtxProto = (globalThis as any).CanvasRenderingContext2D?.prototype;
-  if (CtxProto && originalMeasureText) {
-    CtxProto.measureText = officeMeasureText;
-  }
-}
-
-/**
- * Restore original ctx.measureText.
- */
-export function disableOfficeTextMeasure(): void {
-  if (!officeEnabled) return;
-  officeEnabled = false;
-  officeFontCache = null;
-
-  const CtxProto = (globalThis as any).CanvasRenderingContext2D?.prototype;
-  if (CtxProto && originalMeasureText) {
-    CtxProto.measureText = originalMeasureText;
-  }
-}

package/src/measure/fontkit.d.ts

@@ -1,44 +0,0 @@
-/**
- * Minimal type declarations for fontkit.
- * fontkit does not ship native TypeScript types.
- */
-
-declare module 'fontkit' {
-  interface BBox {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-  }
-
-  interface Glyph {
-    id: number;
-    advanceWidth: number;
-    bbox: BBox;
-    name: string;
-    path: any;
-  }
-
-  interface TTFFont {
-    unitsPerEm: number;
-    ascent: number;
-    descent: number;
-    capHeight: number;
-    xHeight: number;
-    lineGap: number;
-    underlinePosition: number;
-    underlineThickness: number;
-    familyName: string;
-    subfamilyName: string;
-    postscriptName: string;
-    format: string;
-    glyphsForString(text: string): Glyph[];
-    getGlyph(glyphId: number): Glyph;
-  }
-
-  function create(buffer: Buffer, postscriptName?: string): TTFFont;
-  function open(filename: string, postscriptName?: string): Promise<TTFFont>;
-  function openSync(filename: string, postscriptName?: string): TTFFont;
-
-  export { create, open, openSync, TTFFont, Glyph, BBox };
-}