@vyaz/core 0.0.5 → 0.0.7

package/src/measure/FontMetricsProvider.ts

@@ -1,224 +0,0 @@
-/**
- * FontMetricsProvider.ts — isomorphic font metrics provider.
- *
- * Strategy (priority):
- *   1. FontEngine (fontkit) — from registered buffer
- *      - 'browser' mode: hhea.ascender / hhea.descender
- *      - 'office'  mode: OS/2.usWinAscent / OS/2.usWinDescent
- *   2. Canvas TextMetrics (browser fallback when fontkit unavailable)
- *
- * Uses FontEngine as the single entry point for all fontkit operations.
- */
-
-import type { FontMetrics, IFontMetricsProvider } from '../types/FontTypes.js';
-import type { FontFace } from './FontEngine.js';
-import { enableOfficeTextMeasure, disableOfficeTextMeasure } from './canvas-polyfill.js';
-import { FontNotFoundError } from './FontNotFoundError.js';
-
-// ── Reasonable default for missing glyphs ──────────────────────────────────
-
-/**
- * Factor used when a glyph is not found in the font.
- * Multiplied by fontSize to estimate the missing glyph width.
- * Used across all measurement code paths (ParagraphLayoutEngine, canvas-polyfill).
- */
-export const MISSING_GLYPH_FACTOR = 0.5;
-
-// ── 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 {
-  /** Map<string, FontFace> — font engine font face cache */
-  private cache = new Map<string, FontFace>();
-  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 both Node.js and browser the font is loaded via FontEngine.
-   * In the browser the caller must provide font bytes (e.g. fetched via
-   * `getFontBuffer()` from `../utils/font.js`).
-   *
-   * @param source      Font file bytes (ArrayBuffer / Uint8Array), or a URL string
-   * @param sourcePath  Optional filesystem path (used for @napi-rs/canvas in Node.js)
-   */
-  async registerFont(
-    family: string,
-    options: { weight?: string; style?: string },
-    source: string | ArrayBuffer | Uint8Array,
-    sourcePath?: string,
-  ): Promise<void> {
-    const { createFontFace } = await import('./FontEngine.js');
-    const { registerCanvasFont } = await import('./canvas-polyfill.js');
-
-    // Convert string (URL) to buffer — works in browser via fetch
-    if (typeof source === 'string') {
-      const { getFontBuffer } = await import('../utils/font.js');
-      source = await getFontBuffer(source);
-    }
-
-    const font = await createFontFace(source);
-    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);
-    }
-  }
-
-  // ── Font object access (for per-glyph advance) ────────────────────
-
-  /**
-   * Get font engine FontFace object for per-character calculations.
-   * Returns undefined if font is not registered.
-   */
-  getFont(family: string, weight = 'normal', style = 'normal'): FontFace | 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;
-
-    // Strategy 1: FontEngine (fontkit)
-    const font = this.cache.get(key);
-
-    if (font) {
-      // Inline computePixelMetrics to avoid circular ESM import
-      const scale = fontSize / font.unitsPerEm;
-
-      let ascent: number;
-      let descent: number;
-      let sourceTable: 'hhea' | 'OS/2';
-
-      if (this.mode === 'office' && font.winAscent != null && font.winDescent != null) {
-        ascent = font.winAscent * scale * 1.078;
-        descent = Math.abs(font.winDescent) * scale * 1.078;
-        sourceTable = 'OS/2';
-      } else {
-        ascent = font.ascent * scale;
-        descent = Math.abs(font.descent) * scale;
-        sourceTable = 'hhea';
-      }
-
-      const metrics: FontMetrics = {
-        ascent,
-        descent,
-        capHeight: (font.capHeight ?? font.ascent) * scale,
-        unitsPerEm: font.unitsPerEm,
-        sourceTable,
-      };
-
-      this.metricsCache.set(metricsKey, metrics);
-      return metrics;
-    }
-
-    // Strategy 2: If font 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');
-
-        const metrics: FontMetrics = {
-          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 throw
-      }
-    }
-
-    // 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,152 +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';
-import { isNodeLike } from '../utils/env.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> {
-    // System font scanning requires Node.js — no-op in browser
-    if (!isNodeLike) {
-      console.warn('[vyaz] systemFontRegistry.scan() недоступен в браузере');
-      return { total: 0, registered: 0 };
-    }
-
-    // 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);
-
-        // Use FontEngine to extract family name — avoids direct fontkit import
-        const { createFontFace } = await import('./FontEngine.js');
-        const font = await createFontFace(buffer);
-        // Access raw fontkit object for familyName — FontFace doesn't expose it directly
-        // but we need it to know the family before calling registerFont
-        const fontkit = (font as any)._raw;
-        const family = fontkit.familyName;
-        if (!family) continue;
-
-        const { weight, style } = parseSubfamily(fontkit.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,243 +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 FontEngine-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, FontFace> where FontFace._raw holds the
- * raw fontkit font object.  Used by enableOfficeTextMeasure.
- */
-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 fontFace = officeFontCache.get(key);
-  if (!fontFace) {
-    return originalMeasureText?.call(this, text) ?? createEmptyMetrics();
-  }
-
-  // FontFace._raw holds the raw fontkit font object
-  const raw: any = fontFace._raw;
-  const scale = parsed.size / fontFace.unitsPerEm;
-  let totalWidth = 0;
-
-  for (let i = 0; i < text.length; i++) {
-    const codePoint = text.codePointAt(i)!;
-    const glyph = raw.glyphForCodePoint(codePoint);
-    if (glyph) {
-      totalWidth += glyph.advanceWidth * scale;
-    } else {
-      // Fallback for missing glyph: use original
-      if (originalMeasureText) {
-        return originalMeasureText.call(this, text);
-      }
-      // Uses the same MISSING_GLYPH_FACTOR (0.5) as FontMetricsProvider
-      // to avoid circular dependency. Keep in sync.
-      totalWidth += parsed.size * 0.5;
-    }
-    // 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 FontEngine-based version.
- * @param fontCache — Map<family_weight_style, FontFace> 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 };
-}