@cantoo/fontkit 2.0.4 → 2.0.6

package/src/glyph/TTFGlyph.js

@@ -3,46 +3,105 @@ import Path from './Path';
 import BBox from './BBox';
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').DecodeStream} DecodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('../../types/fontkit').DecodedGlyf} DecodedGlyf */
+/** @typedef {import('../../types/fontkit').GlyphComponent} GlyphComponent */
+/** @typedef {import('../../types/fontkit').GlyphMetrics} GlyphMetrics */
+/** @typedef {import('../../types/fontkit').GlyphPoint} GlyphPoint */
+
 // The header for both simple and composite glyphs
 let GlyfHeader = new r.Struct({
   numberOfContours: r.int16, // if negative, this is a composite glyph
-  xMin:             r.int16,
-  yMin:             r.int16,
-  xMax:             r.int16,
-  yMax:             r.int16
+  xMin: r.int16,
+  yMin: r.int16,
+  xMax: r.int16,
+  yMax: r.int16
 });
 
 // Flags for simple glyphs
-const ON_CURVE        = 1 << 0;
-const X_SHORT_VECTOR  = 1 << 1;
-const Y_SHORT_VECTOR  = 1 << 2;
-const REPEAT          = 1 << 3;
-const SAME_X          = 1 << 4;
-const SAME_Y          = 1 << 5;
+const ON_CURVE = 1 << 0;
+const X_SHORT_VECTOR = 1 << 1;
+const Y_SHORT_VECTOR = 1 << 2;
+const REPEAT = 1 << 3;
+const SAME_X = 1 << 4;
+const SAME_Y = 1 << 5;
 
 // Flags for composite glyphs
-const ARG_1_AND_2_ARE_WORDS      = 1 << 0;
-const _ARGS_ARE_XY_VALUES        = 1 << 1;
-const _ROUND_XY_TO_GRID          = 1 << 2;
-const WE_HAVE_A_SCALE            = 1 << 3;
-const MORE_COMPONENTS            = 1 << 5;
-const WE_HAVE_AN_X_AND_Y_SCALE   = 1 << 6;
-const WE_HAVE_A_TWO_BY_TWO       = 1 << 7;
-const WE_HAVE_INSTRUCTIONS       = 1 << 8;
-const _USE_MY_METRICS            = 1 << 9;
-const _OVERLAP_COMPOUND          = 1 << 10;
-const _SCALED_COMPONENT_OFFSET   = 1 << 11;
+const ARG_1_AND_2_ARE_WORDS = 1 << 0;
+const _ARGS_ARE_XY_VALUES = 1 << 1;
+const _ROUND_XY_TO_GRID = 1 << 2;
+const WE_HAVE_A_SCALE = 1 << 3;
+const MORE_COMPONENTS = 1 << 5;
+const WE_HAVE_AN_X_AND_Y_SCALE = 1 << 6;
+const WE_HAVE_A_TWO_BY_TWO = 1 << 7;
+const WE_HAVE_INSTRUCTIONS = 1 << 8;
+const _USE_MY_METRICS = 1 << 9;
+const _OVERLAP_COMPOUND = 1 << 10;
+const _SCALED_COMPONENT_OFFSET = 1 << 11;
 const _UNSCALED_COMPONENT_OFFSET = 1 << 12;
 
+/**
+ * @param {StructValue} raw
+ * @returns {DecodedGlyf}
+ */
+function decodeGlyfHeader(raw) {
+  let numberOfContours = raw.numberOfContours;
+  let xMin = raw.xMin;
+  let yMin = raw.yMin;
+  let xMax = raw.xMax;
+  let yMax = raw.yMax;
+  if (
+    typeof numberOfContours !== 'number'
+    || typeof xMin !== 'number'
+    || typeof yMin !== 'number'
+    || typeof xMax !== 'number'
+    || typeof yMax !== 'number'
+  ) {
+    throw new Error('Invalid glyf header');
+  }
+  return { numberOfContours, xMin, yMin, xMax, yMax };
+}
+
+/**
+ * @param {unknown[]} values
+ * @returns {number[]}
+ */
+function asNumberArray(values) {
+  /** @type {number[]} */
+  let out = [];
+  for (let i = 0; i < values.length; i++) {
+    let v = values[i];
+    if (typeof v !== 'number') {
+      throw new Error('Expected number array from glyf decode');
+    }
+    out.push(v);
+  }
+  return out;
+}
+
 // Represents a point in a simple glyph
 export class Point {
+  /**
+   * @param {boolean} onCurve
+   * @param {boolean} endContour
+   * @param {number} [x]
+   * @param {number} [y]
+   */
   constructor(onCurve, endContour, x = 0, y = 0) {
+    /** @type {boolean} */
     this.onCurve = onCurve;
+    /** @type {boolean} */
     this.endContour = endContour;
+    /** @type {number} */
     this.x = x;
+    /** @type {number} */
     this.y = y;
   }
 
+  /**
+   * @returns {Point}
+   */
   copy() {
     return new Point(this.onCurve, this.endContour, this.x, this.y);
   }
@@ -50,13 +109,28 @@ export class Point {
 
 // Represents a component in a composite glyph
 class Component {
+  /**
+   * @param {number} glyphID
+   * @param {number} dx
+   * @param {number} dy
+   */
   constructor(glyphID, dx, dy) {
+    /** @type {number} */
     this.glyphID = glyphID;
+    /** @type {number} */
     this.dx = dx;
+    /** @type {number} */
     this.dy = dy;
+    /** @type {number} */
     this.pos = 0;
-    this.scaleX = this.scaleY = 1;
-    this.scale01 = this.scale10 = 0;
+    /** @type {number} */
+    this.scaleX = 1;
+    /** @type {number} */
+    this.scaleY = 1;
+    /** @type {number} */
+    this.scale01 = 0;
+    /** @type {number} */
+    this.scale10 = 0;
   }
 }
 
@@ -66,7 +140,11 @@ class Component {
 export default class TTFGlyph extends Glyph {
   type = 'TTF';
 
-  // Parses just the glyph header and returns the bounding box
+  /**
+   * Parses just the glyph header and returns the bounding box
+   * @param {boolean} [internal]
+   * @returns {BBox}
+   */
   _getCBox(internal) {
     // We need to decode the glyph if variation processing is requested,
     // so it's easier just to recompute the path's cbox after decoding.
@@ -74,19 +152,34 @@ export default class TTFGlyph extends Glyph {
       return this.path.cbox;
     }
 
-    let glyfPos = this._font.loca.offsets[this.id];
+    let loca = this._font.loca;
+    if (!loca) {
+      return Object.freeze(new BBox(0, 0, 0, 0));
+    }
+
+    let glyfPos = loca.offsets[this.id];
     // No outline data (e.g. space): avoid decoding the next glyph's header
-    if (glyfPos === this._font.loca.offsets[this.id + 1]) {
+    if (glyfPos === loca.offsets[this.id + 1]) {
       return Object.freeze(new BBox(0, 0, 0, 0));
     }
 
     let stream = this._font._getTableStream('glyf');
+    if (!stream) {
+      return Object.freeze(new BBox(0, 0, 0, 0));
+    }
     stream.pos += glyfPos;
-    let glyph = GlyfHeader.decode(stream);
+    let glyph = decodeGlyfHeader(GlyfHeader.decode(stream));
     return Object.freeze(new BBox(glyph.xMin, glyph.yMin, glyph.xMax, glyph.yMax));
   }
 
-  // Parses a single glyph coordinate
+  /**
+   * Parses a single glyph coordinate
+   * @param {DecodeStream} stream
+   * @param {number} prev
+   * @param {number} short
+   * @param {number} same
+   * @returns {number}
+   */
   _parseGlyphCoord(stream, prev, short, same) {
     let val;
     if (short) {
@@ -107,24 +200,34 @@ export default class TTFGlyph extends Glyph {
     return val;
   }
 
-  // Decodes the glyph data into points for simple glyphs,
-  // or components for composite glyphs
+  /**
+   * Decodes the glyph data into points for simple glyphs,
+   * or components for composite glyphs
+   * @returns {DecodedGlyf | null}
+   */
   _decode() {
-    let glyfPos = this._font.loca.offsets[this.id];
-    let nextPos = this._font.loca.offsets[this.id + 1];
+    let loca = this._font.loca;
+    if (!loca) {
+      return null;
+    }
+
+    let glyfPos = loca.offsets[this.id];
+    let nextPos = loca.offsets[this.id + 1];
 
     // Nothing to do if there is no data for this glyph
     if (glyfPos === nextPos) { return null; }
 
     let stream = this._font._getTableStream('glyf');
+    if (!stream) {
+      return null;
+    }
     stream.pos += glyfPos;
     let startPos = stream.pos;
 
-    let glyph = GlyfHeader.decode(stream);
+    let glyph = decodeGlyfHeader(GlyfHeader.decode(stream));
 
     if (glyph.numberOfContours > 0) {
       this._decodeSimple(glyph, stream);
-
     } else if (glyph.numberOfContours < 0) {
       this._decodeComposite(glyph, stream, startPos);
     }
@@ -132,13 +235,19 @@ export default class TTFGlyph extends Glyph {
     return glyph;
   }
 
+  /**
+   * @param {DecodedGlyf} glyph
+   * @param {DecodeStream} stream
+   * @returns {void}
+   */
   _decodeSimple(glyph, stream) {
     // this is a simple glyph
     glyph.points = [];
 
-    let endPtsOfContours = new r.Array(r.uint16, glyph.numberOfContours).decode(stream);
-    glyph.instructions = new r.Array(r.uint8, r.uint16).decode(stream);
+    let endPtsOfContours = asNumberArray(new r.Array(r.uint16, glyph.numberOfContours).decode(stream));
+    glyph.instructions = asNumberArray(new r.Array(r.uint8, r.uint16).decode(stream));
 
+    /** @type {number[]} */
     let flags = [];
     let numCoords = endPtsOfContours[endPtsOfContours.length - 1] + 1;
 
@@ -164,13 +273,15 @@ export default class TTFGlyph extends Glyph {
     let px = 0;
     for (let i = 0; i < flags.length; i++) {
       let flag = flags[i];
-      glyph.points[i].x = px = this._parseGlyphCoord(stream, px, flag & X_SHORT_VECTOR, flag & SAME_X);
+      let point = glyph.points[i];
+      point.x = px = this._parseGlyphCoord(stream, px, flag & X_SHORT_VECTOR, flag & SAME_X);
     }
 
     let py = 0;
     for (let i = 0; i < flags.length; i++) {
       let flag = flags[i];
-      glyph.points[i].y = py = this._parseGlyphCoord(stream, py, flag & Y_SHORT_VECTOR, flag & SAME_Y);
+      let point = glyph.points[i];
+      point.y = py = this._parseGlyphCoord(stream, py, flag & Y_SHORT_VECTOR, flag & SAME_Y);
     }
 
     if (this._font._variationProcessor) {
@@ -184,6 +295,12 @@ export default class TTFGlyph extends Glyph {
     return;
   }
 
+  /**
+   * @param {DecodedGlyf} glyph
+   * @param {DecodeStream} stream
+   * @param {number} [offset]
+   * @returns {boolean}
+   */
   _decodeComposite(glyph, stream, offset = 0) {
     // this is a composite glyph
     glyph.components = [];
@@ -212,24 +329,23 @@ export default class TTFGlyph extends Glyph {
 
       if (flags & WE_HAVE_A_SCALE) {
         // fixed number with 14 bits of fraction
-        component.scaleX =
-        component.scaleY = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
-
+        component.scaleX
+          = component.scaleY = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
       } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
         component.scaleX = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
         component.scaleY = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
-
       } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
-        component.scaleX  = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
+        component.scaleX = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
         component.scale01 = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
         component.scale10 = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
-        component.scaleY  = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
+        component.scaleY = ((stream.readUInt8() << 24) | (stream.readUInt8() << 16)) / 1073741824;
       }
 
       glyph.components.push(component);
     }
 
     if (this._font._variationProcessor) {
+      /** @type {Point[]} */
       let points = [];
       for (let j = 0; j < glyph.components.length; j++) {
         let component = glyph.components[j];
@@ -251,6 +367,10 @@ export default class TTFGlyph extends Glyph {
     return haveInstructions;
   }
 
+  /**
+   * @param {DecodedGlyf} glyph
+   * @returns {Point[]}
+   */
   _getPhantomPoints(glyph) {
     let cbox = this._getCBox(true);
     if (this._metrics == null) {
@@ -267,20 +387,25 @@ export default class TTFGlyph extends Glyph {
     ];
   }
 
-  // Decodes font data, resolves composite glyphs, and returns an array of contours
+  /**
+   * Decodes font data, resolves composite glyphs, and returns an array of contours
+   * @returns {Point[][]}
+   */
   _getContours() {
     let glyph = this._decode();
     if (!glyph) {
       return [];
     }
 
+    /** @type {Point[]} */
     let points = [];
 
     if (glyph.numberOfContours < 0) {
       // resolve composite glyphs
-      for (let component of glyph.components) {
+      let components = glyph.components || [];
+      for (let component of components) {
         let componentGlyph = this._font._getBaseGlyph(component.glyphID);
-        if (!componentGlyph) {
+        if (!componentGlyph || typeof componentGlyph._getContours !== 'function') {
           continue;
         }
 
@@ -302,18 +427,22 @@ export default class TTFGlyph extends Glyph {
     // Recompute and cache metrics if we performed variation processing, and don't have an HVAR table
     if (glyph.phantomPoints && !this._font.directory.tables.HVAR) {
       let m = this._metrics;
-      m.advanceWidth  = glyph.phantomPoints[1].x - glyph.phantomPoints[0].x;
-      m.advanceHeight = glyph.phantomPoints[3].y - glyph.phantomPoints[2].y;
-      m.leftBearing   = glyph.xMin - glyph.phantomPoints[0].x;
-      m.topBearing    = glyph.phantomPoints[2].y - glyph.yMax;
-      m.rightBearing  = m.advanceWidth - m.leftBearing - m.width;
-      m.bottomBearing = m.advanceHeight - m.topBearing - m.height;
+      if (m) {
+        m.advanceWidth = glyph.phantomPoints[1].x - glyph.phantomPoints[0].x;
+        m.advanceHeight = glyph.phantomPoints[3].y - glyph.phantomPoints[2].y;
+        m.leftBearing = glyph.xMin - glyph.phantomPoints[0].x;
+        m.topBearing = glyph.phantomPoints[2].y - glyph.yMax;
+        m.rightBearing = m.advanceWidth - m.leftBearing - m.width;
+        m.bottomBearing = m.advanceHeight - m.topBearing - m.height;
+      }
     }
 
+    /** @type {Point[][]} */
     let contours = [];
+    /** @type {Point[]} */
     let cur = [];
     for (let k = 0; k < points.length; k++) {
-      var point = points[k];
+      let point = points[k];
       cur.push(point);
       if (point.endContour) {
         contours.push(cur);
@@ -324,6 +453,9 @@ export default class TTFGlyph extends Glyph {
     return contours;
   }
 
+  /**
+   * @returns {GlyphMetrics}
+   */
   _getMetrics() {
     if (this._metrics) {
       return this._metrics;
@@ -337,20 +469,29 @@ export default class TTFGlyph extends Glyph {
       this.path;
     }
 
-    return this._metrics;
+    // super._getMetrics always assigns this._metrics
+    let metrics = this._metrics;
+    if (!metrics) {
+      throw new Error('Failed to compute glyph metrics');
+    }
+    return metrics;
   }
 
-  // Converts contours to a Path object that can be rendered
+  /**
+   * Converts contours to a Path object that can be rendered
+   * @returns {Path}
+   */
   _getPath() {
     let contours = this._getContours();
-    let path = new Path;
+    let path = new Path();
 
     for (let i = 0; i < contours.length; i++) {
       let contour = contours[i];
       let firstPt = contour[0];
       let lastPt = contour[contour.length - 1];
       let start = 0;
-      let curvePt;
+      /** @type {Point | null} */
+      let curvePt = null;
 
       if (firstPt.onCurve) {
         // The first point will be consumed by the moveTo command, so skip in the loop
@@ -376,22 +517,21 @@ export default class TTFGlyph extends Glyph {
 
         if (prevPt.onCurve && pt.onCurve) {
           path.lineTo(pt.x, pt.y);
-
         } else if (prevPt.onCurve && !pt.onCurve) {
           curvePt = pt;
-
         } else if (!prevPt.onCurve && !pt.onCurve) {
           let midX = (prevPt.x + pt.x) / 2;
           let midY = (prevPt.y + pt.y) / 2;
           path.quadraticCurveTo(prevPt.x, prevPt.y, midX, midY);
           curvePt = pt;
-
         } else if (!prevPt.onCurve && pt.onCurve) {
+          if (!curvePt) {
+            throw new Error('Unknown TTF path state');
+          }
           path.quadraticCurveTo(curvePt.x, curvePt.y, pt.x, pt.y);
           curvePt = null;
-
         } else {
-          throw new Error("Unknown TTF path state");
+          throw new Error('Unknown TTF path state');
         }
       }
 

package/src/glyph/TTFGlyphEncoder.js

@@ -1,18 +1,31 @@
 import * as r from 'restructure';
 
+/** @typedef {import('restructure').EncodeStream} EncodeStream */
+/** @typedef {import('restructure').StructValue} StructValue */
+/** @typedef {import('./Path').default} Path */
+
 // Flags for simple glyphs
-const ON_CURVE        = 1 << 0;
-const X_SHORT_VECTOR  = 1 << 1;
-const Y_SHORT_VECTOR  = 1 << 2;
-const REPEAT          = 1 << 3;
-const SAME_X          = 1 << 4;
-const SAME_Y          = 1 << 5;
+const ON_CURVE = 1 << 0;
+const X_SHORT_VECTOR = 1 << 1;
+const Y_SHORT_VECTOR = 1 << 2;
+const REPEAT = 1 << 3;
+const SAME_X = 1 << 4;
+const SAME_Y = 1 << 5;
 
 class Point {
+  /**
+   * @param {number} val
+   * @returns {number}
+   */
   static size(val) {
     return val >= 0 && val <= 255 ? 1 : 2;
   }
-  
+
+  /**
+   * @param {EncodeStream} stream
+   * @param {number} value
+   * @returns {void}
+   */
   static encode(stream, value) {
     if (value >= 0 && value <= 255) {
       stream.writeUInt8(value);
@@ -39,23 +52,32 @@ let Glyf = new r.Struct({
  * Encodes TrueType glyph outlines
  */
 export default class TTFGlyphEncoder {
+  /**
+   * @param {Path} path
+   * @param {number[]} [instructions]
+   * @returns {import('restructure').BinaryBuffer}
+   */
   encodeSimple(path, instructions = []) {
+    /** @type {number[]} */
     let endPtsOfContours = [];
+    /** @type {number[]} */
     let xPoints = [];
+    /** @type {number[]} */
     let yPoints = [];
+    /** @type {number[]} */
     let flags = [];
     let same = 0;
     let lastX = 0, lastY = 0, lastFlag = 0;
     let pointCount = 0;
-    
+
     for (let i = 0; i < path.commands.length; i++) {
       let c = path.commands[i];
-      
+
       for (let j = 0; j < c.args.length; j += 2) {
         let x = c.args[j];
         let y = c.args[j + 1];
         let flag = 0;
-        
+
         // If the ending point of a quadratic curve is the midpoint
         // between the control point and the control point of the next
         // quadratic curve, we can omit the ending point.
@@ -64,21 +86,21 @@ export default class TTFGlyphEncoder {
           if (next && next.command === 'quadraticCurveTo') {
             let midX = (lastX + next.args[0]) / 2;
             let midY = (lastY + next.args[1]) / 2;
-            
+
             if (x === midX && y === midY) {
               continue;
             }
           }
         }
-        
+
         // All points except control points are on curve.
         if (!(c.command === 'quadraticCurveTo' && j === 0)) {
           flag |= ON_CURVE;
         }
-        
+
         flag = this._encodePoint(x, lastX, xPoints, flag, X_SHORT_VECTOR, SAME_X);
         flag = this._encodePoint(y, lastY, yPoints, flag, Y_SHORT_VECTOR, SAME_Y);
-        
+
         if (flag === lastFlag && same < 255) {
           flags[flags.length - 1] |= REPEAT;
           same++;
@@ -87,16 +109,16 @@ export default class TTFGlyphEncoder {
             flags.push(same);
             same = 0;
           }
-      
+
           flags.push(flag);
           lastFlag = flag;
         }
-        
+
         lastX = x;
         lastY = y;
         pointCount++;
       }
-  
+
       if (c.command === 'closePath') {
         endPtsOfContours.push(pointCount - 1);
       }
@@ -106,8 +128,9 @@ export default class TTFGlyphEncoder {
     if (path.commands.length > 1 && path.commands[path.commands.length - 1].command !== 'closePath') {
       endPtsOfContours.push(pointCount - 1);
     }
-    
+
     let bbox = path.bbox;
+    /** @type {StructValue} */
     let glyf = {
       numberOfContours: endPtsOfContours.length,
       xMin: bbox.minX,
@@ -120,24 +143,33 @@ export default class TTFGlyphEncoder {
       xPoints: xPoints,
       yPoints: yPoints
     };
-    
+
     let size = Glyf.size(glyf);
     let tail = 4 - (size % 4);
-    
+
     let stream = new r.EncodeStream(size + tail);
     Glyf.encode(stream, glyf);
-    
+
     // Align to 4-byte length
     if (tail !== 0) {
       stream.fill(0, tail);
     }
-    
+
     return stream.buffer;
   }
-  
+
+  /**
+   * @param {number} value
+   * @param {number} last
+   * @param {number[]} points
+   * @param {number} flag
+   * @param {number} shortFlag
+   * @param {number} sameFlag
+   * @returns {number}
+   */
   _encodePoint(value, last, points, flag, shortFlag, sameFlag) {
     let diff = value - last;
-    
+
     if (value === last) {
       flag |= sameFlag;
     } else {
@@ -149,10 +181,10 @@ export default class TTFGlyphEncoder {
           flag |= sameFlag;
         }
       }
-      
+
       points.push(diff);
     }
-    
+
     return flag;
   }
 }