@vyaz/core 0.0.1 → 0.0.3

package/src/layout/TextFrameLayoutEngine.ts

@@ -2,7 +2,7 @@
  * TextFrameLayoutEngine.ts — Layout a full TextFrame (multi-paragraph).
  *
  * Pipeline:
- *   TextFrame → Paragraph[] → paragraphLayoutEngine.layout() each → merge LineBox[]
+ *   TextFrame → Paragraph[] → paragraphLayoutEngine.layout() each → merge Line[]
  *
  * Handles:
  * - Paragraph stacking with Y offset accumulation
@@ -10,7 +10,7 @@
  * - frame.width/height optional → fitHorizontal/fitVertical flags
  */
 import type { TextFrame } from '../types/Document.js';
-import type { LineBox } from '../types/LayoutTypes.js';
+import type { Line } from '../types/LayoutTypes.js';
 import { paragraphLayoutEngine } from './ParagraphLayoutEngine.js';
 
 /**
@@ -21,7 +21,7 @@ import { paragraphLayoutEngine } from './ParagraphLayoutEngine.js';
  * - `'content'` → use `contentWidth` / `contentHeight`
  */
 export interface TextFrameLayoutResult {
-  lines: LineBox[];
+  lines: Line[];
   /** Frame width (set when TextFrame.width was provided). */
   frameWidth?: number;
   /** Frame height (set when TextFrame.height was provided). */
@@ -40,8 +40,8 @@ export interface TextFrameLayoutResult {
  * Layout a full TextFrame by stacking paragraphs with Y offset accumulation.
  */
 export function layoutTextFrame(frame: TextFrame): TextFrameLayoutResult {
-  const allLines: LineBox[] = [];
-  let yOffset = 0;
+  const allLines: Line[] = [];
+  let yOffset = frame.padding?.top ?? 0;
   let contentWidth = 0;
 
   const leftPad = frame.padding?.left ?? 0;
@@ -56,6 +56,11 @@ export function layoutTextFrame(frame: TextFrame): TextFrameLayoutResult {
       ? frame.width - leftPad - rightPad
       : Infinity;
 
+    // If wrap is disabled, force no-wrap on the paragraph
+    if (frame.wrap === false) {
+      p.style = { ...p.style, whiteSpace: 'nowrap' };
+    }
+
     const result = paragraphLayoutEngine.layout(p, maxWidth, yOffset);
 
     for (const line of result.lines) {
@@ -83,4 +88,4 @@ export function layoutTextFrame(frame: TextFrame): TextFrameLayoutResult {
     fitHorizontal: frame.width !== undefined ? 'frame' : 'content',
     fitVertical: frame.height !== undefined ? 'frame' : 'content',
   };
-}
+}

package/src/measure/FontMetricsProvider.ts

@@ -12,11 +12,43 @@
  */
 
 import type { FontMetrics, IFontMetricsProvider } from '../types/FontTypes.js';
-import { enableOfficeTextMeasure, disableOfficeTextMeasure } from './canvas-polyfill.js';
+import { enableOfficeTextMeasure, disableOfficeTextMeasure, registerCanvasFont } from './canvas-polyfill.js';
+import { FontNotFoundError } from './FontNotFoundError.js';
 
-/** Cache key: "${family}_${weight}_${style}" */
+// ── 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}_${weight}_${style}`;
+  return `${family}_${normaliseWeight(weight)}_${style}`;
 }
 
 export class FontMetricsProvider implements IFontMetricsProvider {
@@ -48,12 +80,15 @@ export class FontMetricsProvider implements IFontMetricsProvider {
 
   /**
    * Register a binary font for use with fontkit.
-   * In browser — no-op.
+   * 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
@@ -70,6 +105,11 @@ export class FontMetricsProvider implements IFontMetricsProvider {
       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
     }
@@ -150,7 +190,12 @@ export class FontMetricsProvider implements IFontMetricsProvider {
       return metrics;
     }
 
-    // Strategy 2: Canvas TextMetrics (browser)
+    // 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');
@@ -172,17 +217,8 @@ export class FontMetricsProvider implements IFontMetricsProvider {
       }
     }
 
-    console.error("Font not found")
-    // Strategy 3: Fallback
-    metrics = {
-      ascent: fontSize * 0.85,
-      descent: fontSize * 0.15,
-      capHeight: fontSize * 0.7,
-      unitsPerEm: 1000,
-      sourceTable: 'fallback',
-    };
-    this.metricsCache.set(metricsKey, metrics);
-    return metrics;
+    // Font not found — throw error with clear message
+    throw new FontNotFoundError(fontFamily, weight, style);
   }
 }
 

package/src/measure/FontNotFoundError.ts

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,141 @@
+/**
+ * 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());
+ */
+
+import { readFileSync } from 'node:fs';
+import getSystemFonts from 'get-system-fonts';
+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> {
+    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.ts

@@ -10,13 +10,15 @@
  * Exports enableOfficeTextMeasure / disableOfficeTextMeasure —
  * ctx.measureText override for fontkit-based measurements in Office mode.
  */
+import { createRequire } from 'module';
+
 // ⚠️ Dynamic import — prevents esbuild from resolving @napi-rs/canvas at bundle time.
 // This module is a native Node.js addon. In the browser, Canvas APIs are already available.
 let _createCanvas: ((w: number, h: number) => any) | null = null;
 
+const _require = createRequire(import.meta.url);
 try {
-  // Dynamic require — kept as eval to avoid esbuild static analysis
-  const mod: any = (Function('return require("@napi-rs/canvas")'))();
+  const mod: any = _require('@napi-rs/canvas');
   _createCanvas = mod.createCanvas;
 } catch {
   // Browser — document.createElement('canvas') is available natively, no polyfill needed
@@ -28,7 +30,18 @@ try {
 // to create a temporary Canvas and obtain a 2d context for measureText.
 // Without this polyfill, prepare() crashes with "document is not defined" in Bun.
 
-if (typeof globalThis.document === 'undefined') {
+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);
@@ -156,6 +169,21 @@ 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 {
+  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

package/src/types/FontTypes.ts

@@ -45,11 +45,14 @@ export interface IFontMetricsProvider {
   /**
    * Register a binary font for use with fontkit.
    * In browser — no-op (fonts are registered via CSS @font-face).
+   *
+   * @param sourcePath — path to .ttf/.otf file for optional @napi-rs/canvas.registerFont()
    */
   registerFont(
     family: string,
     options: { weight?: string; style?: string },
     source: string | Buffer,
+    sourcePath?: string,
   ): void;
 
   /**

package/src/types/LayoutTypes.ts

@@ -1,7 +1,7 @@
 /**
  * LayoutTypes.ts — output types (Physical Box Model).
  *
- * ParagraphLayoutResult → LineBox[] → FragmentBox[]
+ * ParagraphLayoutResult → Line[] → Span[]
  * This is the contract between layout engine and renderers.
  *
  * Based on plan.md §2.5 (Output — Physical Box Model / Layout Tree)
@@ -9,22 +9,22 @@
 
 import type { TextRun, InlineWidget, TextAlignment } from './Document.js';
 
-// ── FragmentBox (render atom) ─────────────────────────────────────────────
+// ── Span (render atom, formerly FragmentBox) ─────────────────────────────
 
-export interface FragmentBox {
-  /** Offset from LineBox.x */
+export interface Span {
+  /** Offset from Line.x */
   x: number;
-  /** Physical fragment width */
+  /** Physical span width */
   width: number;
-  /** Fragment text (or " " for justify spaces) */
+  /** Span text (or " " for justify spaces) */
   text: string;
   /** Index of the source run in the paragraph's `children` array. */
   itemIndex: number;
   /** ID of the source paragraph (for SVG grouping). */
   paragraphId?: string;
 
-  /** Physical font metrics for this fragment */
-  fontMetrics: FragmentFontMetrics;
+  /** Physical font metrics for this span */
+  fontMetrics: SpanFontMetrics;
 
   /**
    * A snapshot of the source run's style at layout time.
@@ -32,20 +32,20 @@ export interface FragmentBox {
    */
   style: TextRun;
 
-  /** InlineWidget data (if fragment is an inline-box) */
+  /** InlineWidget data (if span is an inline-box) */
   inlineWidget?: InlineWidget;
 
   /** Per-character advance widths (for selection/tracking) */
   glyphAdvances?: number[];
 
-  /** Fragment type: 'text' — regular text, 'space' — whitespace fragment */
+  /** Span type: 'text' — regular text, 'space' — whitespace span */
   type: 'text' | 'space';
 
   /**
    * Trailing whitespace flag.
-   * - true: fragment is at end of line, does not participate in line advance
+   * - true: span is at end of line, does not participate in line advance
    *         and is not stretched during justify (zero width for calculations).
-   * - undefined/false: regular fragment.
+   * - undefined/false: regular span.
    *
    * See CSS Text Module Level 3 §4.1.3 (Tracking and Dropping Spaces)
    * and Parley LineItemData::has_trailing_whitespace.
@@ -53,7 +53,7 @@ export interface FragmentBox {
   trailing?: boolean;
 
   /**
-   * Line break mode after this fragment.
+   * Line break mode after this span.
    * 'soft' — soft line break (insufficient space)
    * 'hard' — forced break (\n, explicit separator)
    * undefined — not end of line
@@ -61,22 +61,26 @@ export interface FragmentBox {
   breakType?: 'soft' | 'hard';
 }
 
-export interface FragmentFontMetrics {
+export interface SpanFontMetrics {
   ascent: number;
   descent: number;
   fontSize: number;
+  /** Vertical offset from baseline (px). Used for sub/superscript positioning.
+   *  Negative = above baseline (superscript). Positive = below baseline (subscript).
+   *  Undefined or 0 = normal baseline position. */
+  baselineOffset?: number;
 }
 
-// ── LineBox (single line) ────────────────────────────────────────────────
+// ── Line (single line, formerly LineBox) ─────────────────────────────────
 
-export interface LineBox {
+export interface Line {
   /** Absolute X within container (alignment + indent) */
   x: number;
   /** Absolute Y of line top edge */
   y: number;
   /** Line content width (without alignment) */
   width: number;
-  /** Full line height (max fragments × lineHeight) */
+  /** Full line height (max spans × lineHeight) */
   height: number;
 
   /** Baseline offset from y */
@@ -94,7 +98,7 @@ export interface LineBox {
   /** Paragraph alignment (optional, for PowerPoint render) */
   alignment?: TextAlignment;
 
-  fragments: FragmentBox[];
+  spans: Span[];
 }
 
 // ── ParagraphLayoutResult (single paragraph) ─────────────────────────────
@@ -102,7 +106,7 @@ export interface LineBox {
 export interface ParagraphLayoutResult {
   width: number;             // paragraph width (maxWidth)
   height: number;            // full paragraph height including spacing
-  lines: LineBox[];
+  lines: Line[];
   /** Actual content width (text bbox, without voids) */
   contentWidth: number;
   /** Actual content height (text bbox) */
@@ -111,7 +115,7 @@ export interface ParagraphLayoutResult {
 
 // ── Text region for YAML snapshots ───────────────────────────────────────
 
-/** Semantic fragment for snapshots (without physical metrics) */
+/** Semantic span for snapshots (without physical metrics) */
 export interface SemanticFragment {
   text: string;
   x: number;
@@ -133,4 +137,5 @@ export interface SemanticParagraph {
   width: number;
   height: number;
   lines: SemanticLine[];
-}
+}
+