@vyaz/core 0.0.10 → 0.0.11

package/dist/index.browser.js

@@ -18200,12 +18200,31 @@ function normaliseWeight(weight) {
     return mapped;
   return weight;
 }
-function cacheKey2(family, weight, style) {
-  return `${family}_${normaliseWeight(weight)}_${style}`;
+function weightToNumber(weight) {
+  const num = parseInt(weight, 10);
+  return isNaN(num) ? 400 : num;
+}
+function variantKey(weight, style) {
+  return `${normaliseWeight(weight)}_${style}`;
+}
+function nearestWeight(registeredWeights, requested) {
+  if (registeredWeights.length === 0)
+    return null;
+  let best = registeredWeights[0];
+  let bestDist = Math.abs(best - requested);
+  for (let i = 1;i < registeredWeights.length; i++) {
+    const w = registeredWeights[i];
+    const dist = Math.abs(w - requested);
+    if (dist < bestDist || dist === bestDist && w > best) {
+      best = w;
+      bestDist = dist;
+    }
+  }
+  return best;
 }
 
 class FontMetricsProvider {
-  cache = new Map;
+  registry = new Map;
   metricsCache = new Map;
   mode = "browser";
   pendingRegistrations = new Set;
@@ -18229,7 +18248,7 @@ class FontMetricsProvider {
     this.mode = mode;
     this.metricsCache.clear();
     if (mode === "office") {
-      enableOfficeTextMeasure(this.cache);
+      enableOfficeTextMeasure(this._flattenCache());
     } else {
       disableOfficeTextMeasure();
     }
@@ -18237,6 +18256,15 @@ class FontMetricsProvider {
   getMode() {
     return this.mode;
   }
+  _flattenCache() {
+    const flat = new Map;
+    for (const [family, variants] of this.registry) {
+      for (const [vKey, font] of variants) {
+        flat.set(`${family}_${vKey}`, font);
+      }
+    }
+    return flat;
+  }
   async registerFont(family, options, source, sourcePath) {
     const promise = this._registerFontInternal(family, options, source, sourcePath);
     this.pendingRegistrations.add(promise);
@@ -18254,9 +18282,18 @@ class FontMetricsProvider {
       source = await getFontBuffer2(source);
     }
     const font = await createFontFace2(source);
-    const key = cacheKey2(family, options.weight || "normal", options.style || "normal");
-    this.cache.set(key, font);
-    this.metricsCache.delete(key);
+    const w = options.weight || "normal";
+    const s = options.style || "normal";
+    const vKey = variantKey(w, s);
+    if (!this.registry.has(family)) {
+      this.registry.set(family, new Map);
+    }
+    this.registry.get(family).set(vKey, font);
+    for (const key of this.metricsCache.keys()) {
+      if (key.startsWith(family)) {
+        this.metricsCache.delete(key);
+      }
+    }
     if (sourcePath) {
       registerCanvasFont2(sourcePath, family);
     }
@@ -18264,22 +18301,88 @@ class FontMetricsProvider {
   async waitForPendingRegistrations() {
     await Promise.all(this.pendingRegistrations);
   }
+  getRegisteredFamilies() {
+    return Array.from(this.registry.keys());
+  }
+  getFamilyVariants(family) {
+    const variants = this.registry.get(family);
+    return variants ? Array.from(variants.keys()) : [];
+  }
   getFont(family, weight = "normal", style = "normal") {
-    const key = cacheKey2(family, weight, style);
-    return this.cache.get(key);
+    const resolved = this._resolveFont(family, weight, style);
+    if (!resolved)
+      return;
+    return resolved.font;
+  }
+  _resolveFont(family, weight, style) {
+    const variants = this.registry.get(family);
+    if (!variants || variants.size === 0)
+      return null;
+    const normalisedW = normaliseWeight(weight);
+    const normalisedS = style;
+    let key = variantKey(normalisedW, normalisedS);
+    let font = variants.get(key);
+    if (font)
+      return { font, resolvedWeight: normalisedW, resolvedStyle: normalisedS };
+    if (normalisedS === "italic") {
+      key = variantKey(normalisedW, "normal");
+      font = variants.get(key);
+      if (font)
+        return { font, resolvedWeight: normalisedW, resolvedStyle: "normal" };
+    }
+    const sameStyleWeights = [];
+    for (const vKey of variants.keys()) {
+      const [_w, _s] = vKey.split("_");
+      if (_s === normalisedS) {
+        sameStyleWeights.push(weightToNumber(_w));
+      }
+    }
+    const sameStyleNearest = nearestWeight(sameStyleWeights, weightToNumber(normalisedW));
+    if (sameStyleNearest !== null) {
+      key = variantKey(String(sameStyleNearest), normalisedS);
+      font = variants.get(key);
+      if (font)
+        return { font, resolvedWeight: String(sameStyleNearest), resolvedStyle: normalisedS };
+    }
+    if (normalisedS === "italic") {
+      const normalWeights = [];
+      for (const vKey of variants.keys()) {
+        const [_w, _s] = vKey.split("_");
+        if (_s === "normal") {
+          normalWeights.push(weightToNumber(_w));
+        }
+      }
+      const normalNearest = nearestWeight(normalWeights, weightToNumber(normalisedW));
+      if (normalNearest !== null) {
+        key = variantKey(String(normalNearest), "normal");
+        font = variants.get(key);
+        if (font)
+          return { font, resolvedWeight: String(normalNearest), resolvedStyle: "normal" };
+      }
+    }
+    const firstKey = variants.keys().next().value;
+    if (firstKey) {
+      font = variants.get(firstKey);
+      if (font) {
+        const [_w, _s] = firstKey.split("_");
+        return { font, resolvedWeight: _w, resolvedStyle: _s };
+      }
+    }
+    return null;
   }
   getMetrics(fontFamily, fontSize, weight = "normal", style = "normal") {
     const _process2 = typeof globalThis !== "undefined" ? globalThis.process : undefined;
     if (this.pendingRegistrations.size > 0 && _process2?.env?.NODE_ENV !== "production") {
       console.warn("[vyaz] getMetrics() called while registerFont() promises are still pending. Wait for registerFont() to resolve before layout to avoid inaccurate metrics. Use fontMetricsProvider.waitForPendingRegistrations() if needed.");
     }
-    const key = cacheKey2(fontFamily, weight, style);
-    const metricsKey = `${key}_${fontSize}_${this.mode}`;
+    const normalisedW = normaliseWeight(weight);
+    const metricsKey = `${fontFamily}_${normalisedW}_${style}_${fontSize}_${this.mode}`;
     const cached = this.metricsCache.get(metricsKey);
     if (cached)
       return cached;
-    const font = this.cache.get(key);
-    if (font) {
+    const resolved = this._resolveFont(fontFamily, weight, style);
+    if (resolved) {
+      const font = resolved.font;
       const scale = fontSize / font.unitsPerEm;
       let ascent;
       let descent;
@@ -18303,7 +18406,7 @@ class FontMetricsProvider {
       this.metricsCache.set(metricsKey, metrics);
       return metrics;
     }
-    if (this.cache.size > 0) {
+    if (this.registry.has(fontFamily)) {
       throw new FontNotFoundError(fontFamily, weight, style);
     }
     if (typeof document !== "undefined") {
@@ -24368,15 +24471,15 @@ function isLineStartCursor(cursor) {
   return cursor.segmentIndex === 0 && cursor.graphemeIndex === 0;
 }
 function getCollapsedSpaceWidth(font, letterSpacing, cache) {
-  const cacheKey3 = `${font}\x00${letterSpacing}`;
-  const cached = cache.get(cacheKey3);
+  const cacheKey2 = `${font}\x00${letterSpacing}`;
+  const cached = cache.get(cacheKey2);
   if (cached !== undefined)
     return cached;
   const options = letterSpacing === 0 ? undefined : { letterSpacing };
   const joinedWidth = measureNaturalWidth(prepareWithSegments("A A", font, options));
   const compactWidth = measureNaturalWidth(prepareWithSegments("AA", font, options));
   const collapsedWidth = Math.max(0, joinedWidth - compactWidth);
-  cache.set(cacheKey3, collapsedWidth);
+  cache.set(cacheKey2, collapsedWidth);
   return collapsedWidth;
 }
 function prepareWholeItemLine(prepared) {
@@ -24621,11 +24724,11 @@ class ParagraphLayoutEngine {
   layout(paragraph, maxWidth, yOffset = 0, fontProvider, listStyle, listIndex, listMarkerWidth) {
     const provider = fontProvider || fontMetricsProvider;
     const items = compileParagraph(paragraph);
-    const cacheKey3 = JSON.stringify(paragraph);
-    let prepared = this.preparedCache.get(cacheKey3);
+    const cacheKey2 = JSON.stringify(paragraph);
+    let prepared = this.preparedCache.get(cacheKey2);
     if (!prepared) {
       prepared = prepareRichInline(items);
-      this.preparedCache.set(cacheKey3, prepared);
+      this.preparedCache.set(cacheKey2, prepared);
     }
     const effectiveMaxWidth = paragraph.style.whiteSpace === "nowrap" ? Infinity : maxWidth;
     const pretextLines = [];

package/dist/index.js

@@ -497,12 +497,31 @@ function normaliseWeight(weight) {
     return mapped;
   return weight;
 }
-function cacheKey2(family, weight, style) {
-  return `${family}_${normaliseWeight(weight)}_${style}`;
+function weightToNumber(weight) {
+  const num = parseInt(weight, 10);
+  return isNaN(num) ? 400 : num;
+}
+function variantKey(weight, style) {
+  return `${normaliseWeight(weight)}_${style}`;
+}
+function nearestWeight(registeredWeights, requested) {
+  if (registeredWeights.length === 0)
+    return null;
+  let best = registeredWeights[0];
+  let bestDist = Math.abs(best - requested);
+  for (let i = 1;i < registeredWeights.length; i++) {
+    const w = registeredWeights[i];
+    const dist = Math.abs(w - requested);
+    if (dist < bestDist || dist === bestDist && w > best) {
+      best = w;
+      bestDist = dist;
+    }
+  }
+  return best;
 }
 
 class FontMetricsProvider {
-  cache = new Map;
+  registry = new Map;
   metricsCache = new Map;
   mode = "browser";
   pendingRegistrations = new Set;
@@ -526,7 +545,7 @@ class FontMetricsProvider {
     this.mode = mode;
     this.metricsCache.clear();
     if (mode === "office") {
-      enableOfficeTextMeasure(this.cache);
+      enableOfficeTextMeasure(this._flattenCache());
     } else {
       disableOfficeTextMeasure();
     }
@@ -534,6 +553,15 @@ class FontMetricsProvider {
   getMode() {
     return this.mode;
   }
+  _flattenCache() {
+    const flat = new Map;
+    for (const [family, variants] of this.registry) {
+      for (const [vKey, font] of variants) {
+        flat.set(`${family}_${vKey}`, font);
+      }
+    }
+    return flat;
+  }
   async registerFont(family, options, source, sourcePath) {
     const promise = this._registerFontInternal(family, options, source, sourcePath);
     this.pendingRegistrations.add(promise);
@@ -551,9 +579,18 @@ class FontMetricsProvider {
       source = await getFontBuffer2(source);
     }
     const font = await createFontFace2(source);
-    const key = cacheKey2(family, options.weight || "normal", options.style || "normal");
-    this.cache.set(key, font);
-    this.metricsCache.delete(key);
+    const w = options.weight || "normal";
+    const s = options.style || "normal";
+    const vKey = variantKey(w, s);
+    if (!this.registry.has(family)) {
+      this.registry.set(family, new Map);
+    }
+    this.registry.get(family).set(vKey, font);
+    for (const key of this.metricsCache.keys()) {
+      if (key.startsWith(family)) {
+        this.metricsCache.delete(key);
+      }
+    }
     if (sourcePath) {
       registerCanvasFont2(sourcePath, family);
     }
@@ -561,22 +598,88 @@ class FontMetricsProvider {
   async waitForPendingRegistrations() {
     await Promise.all(this.pendingRegistrations);
   }
+  getRegisteredFamilies() {
+    return Array.from(this.registry.keys());
+  }
+  getFamilyVariants(family) {
+    const variants = this.registry.get(family);
+    return variants ? Array.from(variants.keys()) : [];
+  }
   getFont(family, weight = "normal", style = "normal") {
-    const key = cacheKey2(family, weight, style);
-    return this.cache.get(key);
+    const resolved = this._resolveFont(family, weight, style);
+    if (!resolved)
+      return;
+    return resolved.font;
+  }
+  _resolveFont(family, weight, style) {
+    const variants = this.registry.get(family);
+    if (!variants || variants.size === 0)
+      return null;
+    const normalisedW = normaliseWeight(weight);
+    const normalisedS = style;
+    let key = variantKey(normalisedW, normalisedS);
+    let font = variants.get(key);
+    if (font)
+      return { font, resolvedWeight: normalisedW, resolvedStyle: normalisedS };
+    if (normalisedS === "italic") {
+      key = variantKey(normalisedW, "normal");
+      font = variants.get(key);
+      if (font)
+        return { font, resolvedWeight: normalisedW, resolvedStyle: "normal" };
+    }
+    const sameStyleWeights = [];
+    for (const vKey of variants.keys()) {
+      const [_w, _s] = vKey.split("_");
+      if (_s === normalisedS) {
+        sameStyleWeights.push(weightToNumber(_w));
+      }
+    }
+    const sameStyleNearest = nearestWeight(sameStyleWeights, weightToNumber(normalisedW));
+    if (sameStyleNearest !== null) {
+      key = variantKey(String(sameStyleNearest), normalisedS);
+      font = variants.get(key);
+      if (font)
+        return { font, resolvedWeight: String(sameStyleNearest), resolvedStyle: normalisedS };
+    }
+    if (normalisedS === "italic") {
+      const normalWeights = [];
+      for (const vKey of variants.keys()) {
+        const [_w, _s] = vKey.split("_");
+        if (_s === "normal") {
+          normalWeights.push(weightToNumber(_w));
+        }
+      }
+      const normalNearest = nearestWeight(normalWeights, weightToNumber(normalisedW));
+      if (normalNearest !== null) {
+        key = variantKey(String(normalNearest), "normal");
+        font = variants.get(key);
+        if (font)
+          return { font, resolvedWeight: String(normalNearest), resolvedStyle: "normal" };
+      }
+    }
+    const firstKey = variants.keys().next().value;
+    if (firstKey) {
+      font = variants.get(firstKey);
+      if (font) {
+        const [_w, _s] = firstKey.split("_");
+        return { font, resolvedWeight: _w, resolvedStyle: _s };
+      }
+    }
+    return null;
   }
   getMetrics(fontFamily, fontSize, weight = "normal", style = "normal") {
     const _process2 = typeof globalThis !== "undefined" ? globalThis.process : undefined;
     if (this.pendingRegistrations.size > 0 && _process2?.env?.NODE_ENV !== "production") {
       console.warn("[vyaz] getMetrics() called while registerFont() promises are still pending. Wait for registerFont() to resolve before layout to avoid inaccurate metrics. Use fontMetricsProvider.waitForPendingRegistrations() if needed.");
     }
-    const key = cacheKey2(fontFamily, weight, style);
-    const metricsKey = `${key}_${fontSize}_${this.mode}`;
+    const normalisedW = normaliseWeight(weight);
+    const metricsKey = `${fontFamily}_${normalisedW}_${style}_${fontSize}_${this.mode}`;
     const cached = this.metricsCache.get(metricsKey);
     if (cached)
       return cached;
-    const font = this.cache.get(key);
-    if (font) {
+    const resolved = this._resolveFont(fontFamily, weight, style);
+    if (resolved) {
+      const font = resolved.font;
       const scale = fontSize / font.unitsPerEm;
       let ascent;
       let descent;
@@ -600,7 +703,7 @@ class FontMetricsProvider {
       this.metricsCache.set(metricsKey, metrics);
       return metrics;
     }
-    if (this.cache.size > 0) {
+    if (this.registry.has(fontFamily)) {
       throw new FontNotFoundError(fontFamily, weight, style);
     }
     if (typeof document !== "undefined") {
@@ -1170,11 +1273,11 @@ class ParagraphLayoutEngine {
   layout(paragraph, maxWidth, yOffset = 0, fontProvider, listStyle, listIndex, listMarkerWidth) {
     const provider = fontProvider || fontMetricsProvider;
     const items = compileParagraph(paragraph);
-    const cacheKey3 = JSON.stringify(paragraph);
-    let prepared = this.preparedCache.get(cacheKey3);
+    const cacheKey2 = JSON.stringify(paragraph);
+    let prepared = this.preparedCache.get(cacheKey2);
     if (!prepared) {
       prepared = prepareRichInline(items);
-      this.preparedCache.set(cacheKey3, prepared);
+      this.preparedCache.set(cacheKey2, prepared);
     }
     const effectiveMaxWidth = paragraph.style.whiteSpace === "nowrap" ? Infinity : maxWidth;
     const pretextLines = [];

package/dist/measure/FontMetricsProvider.d.ts

@@ -2,63 +2,69 @@
  * 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
+ *   1. FontEngine (fontkit) — from registered buffer, with smart weight fallback
  *   2. Canvas TextMetrics (browser fallback when fontkit unavailable)
  *
- * Uses FontEngine as the single entry point for all fontkit operations.
+ * Key features:
+ *   - Nested registry: family → variants (weight + style)
+ *   - Smart weight fallback: if exact weight not found, picks closest
+ *   - Style fallback: if exact style not found, falls back to 'normal'
+ *   - Tracks pending registrations to warn about race conditions
+ *   - Reusable off-screen canvas for Canvas TextMetrics fallback
  */
 import type { FontMetrics, IFontMetricsProvider } from '../types/FontTypes.js';
 import type { FontFace } from './FontEngine.js';
 /**
  * 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 declare const MISSING_GLYPH_FACTOR = 0.5;
 export declare class FontMetricsProvider implements IFontMetricsProvider {
-    /** Map<string, FontFace> — font engine font face cache */
-    private cache;
+    /**
+     * Nested registry: family → variantKey → FontFace.
+     * Example:
+     *   "Roboto" → { "400_normal": FontFace, "700_normal": FontFace, "400_italic": FontFace }
+     */
+    private registry;
+    /** Metrics cache keyed by variantKey_fontSize_mode */
     private metricsCache;
     private mode;
-    /** Set of in-flight registerFont() promises for race-condition guarding */
     private pendingRegistrations;
     private _measureCanvas;
     private _measureCtx;
-    /** Get or create a reusable canvas context for Canvas TextMetrics. */
     private _getMeasureContext;
     setMode(mode: 'browser' | 'office'): void;
     getMode(): 'browser' | 'office';
     /**
-     * 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`).
-     *
-     * Tracks pending registrations to detect race conditions where
-     * getMetrics() is called before registration completes.
-     *
-     * @param source      Font file bytes (ArrayBuffer / Uint8Array), or a URL string
-     * @param sourcePath  Optional filesystem path (used for @napi-rs/canvas in Node.js)
+     * Flatten the nested registry into a single map for office mode.
+     * Office mode needs key → FontFace lookup by family_weight_style.
      */
+    private _flattenCache;
     registerFont(family: string, options: {
         weight?: string;
         style?: string;
     }, source: string | ArrayBuffer | Uint8Array, sourcePath?: string): Promise<void>;
-    /** Internal registration logic — not tracked, exposed for direct use if needed. */
     private _registerFontInternal;
+    waitForPendingRegistrations(): Promise<void>;
     /**
-     * Wait for all in-flight font registrations to complete.
-     * Useful after a batch of registerFont() calls before layout.
+     * List all families registered in the provider.
      */
-    waitForPendingRegistrations(): Promise<void>;
+    getRegisteredFamilies(): string[];
     /**
-     * Get font engine FontFace object for per-character calculations.
-     * Returns undefined if font is not registered.
+     * Get all variant keys registered for a given family.
+     * Returns empty array if family not found.
+     */
+    getFamilyVariants(family: string): string[];
+    /**
+     * Get font engine FontFace for per-character calculations.
+     * Uses the same smart fallback logic as getMetrics().
      */
     getFont(family: string, weight?: string, style?: string): FontFace | undefined;
+    /**
+     * Resolve a font request with fallback.
+     * Returns { font, resolvedWeight, resolvedStyle } or null.
+     */
+    private _resolveFont;
     getMetrics(fontFamily: string, fontSize: number, weight?: string, style?: string): FontMetrics;
 }
 /** Singleton */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyaz/core",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",