@cantoo/fontkit 2.0.4 → 2.0.6

package/src/glyph/GlyphVariationProcessor.js

@@ -1,14 +1,20 @@
+/** @typedef {import('../../types/fontkit').FontLike} FontLike */
+/** @typedef {import('../../types/fontkit').GlyphPoint} GlyphPoint */
+/** @typedef {import('../../types/fontkit').HVARTable} HVARTable */
+/** @typedef {import('../../types/fontkit').ItemVariationStore} ItemVariationStore */
+/** @typedef {import('../../types/fontkit').ItemVariationData} ItemVariationData */
+
 const TUPLES_SHARE_POINT_NUMBERS = 0x8000;
-const TUPLE_COUNT_MASK           = 0x0fff;
-const EMBEDDED_TUPLE_COORD       = 0x8000;
-const INTERMEDIATE_TUPLE         = 0x4000;
-const PRIVATE_POINT_NUMBERS      = 0x2000;
-const TUPLE_INDEX_MASK           = 0x0fff;
-const POINTS_ARE_WORDS           = 0x80;
-const POINT_RUN_COUNT_MASK       = 0x7f;
-const DELTAS_ARE_ZERO            = 0x80;
-const DELTAS_ARE_WORDS           = 0x40;
-const DELTA_RUN_COUNT_MASK       = 0x3f;
+const TUPLE_COUNT_MASK = 0x0fff;
+const EMBEDDED_TUPLE_COORD = 0x8000;
+const INTERMEDIATE_TUPLE = 0x4000;
+const PRIVATE_POINT_NUMBERS = 0x2000;
+const TUPLE_INDEX_MASK = 0x0fff;
+const POINTS_ARE_WORDS = 0x80;
+const POINT_RUN_COUNT_MASK = 0x7f;
+const DELTAS_ARE_ZERO = 0x80;
+const DELTAS_ARE_WORDS = 0x40;
+const DELTA_RUN_COUNT_MASK = 0x3f;
 
 /**
  * This class is transforms TrueType glyphs according to the data from
@@ -22,18 +28,35 @@ const DELTA_RUN_COUNT_MASK       = 0x3f;
  * @private
  */
 export default class GlyphVariationProcessor {
+  /**
+   * @param {FontLike} font
+   * @param {number[]} coords
+   */
   constructor(font, coords) {
+    /** @type {FontLike} */
     this.font = font;
+    /** @type {number[]} */
     this.normalizedCoords = this.normalizeCoords(coords);
-    this.blendVectors = new Map;
+    /** @type {Map<ItemVariationData, number[]>} */
+    this.blendVectors = new Map();
   }
 
+  /**
+   * @param {number[]} coords
+   * @returns {number[]}
+   */
   normalizeCoords(coords) {
     // the default mapping is linear along each axis, in two segments:
     // from the minValue to defaultValue, and from defaultValue to maxValue.
+    /** @type {number[]} */
     let normalized = [];
-    for (let i = 0; i < this.font.fvar.axis.length; i++) {
-      let axis = this.font.fvar.axis[i];
+    let fvar = this.font.fvar;
+    if (!fvar) {
+      return normalized;
+    }
+
+    for (let i = 0; i < fvar.axis.length; i++) {
+      let axis = fvar.axis[i];
       if (coords[i] < axis.defaultValue) {
         normalized.push((coords[i] - axis.defaultValue + Number.EPSILON) / (axis.defaultValue - axis.minValue + Number.EPSILON));
       } else {
@@ -50,9 +73,9 @@ export default class GlyphVariationProcessor {
           let pair = segment.correspondence[j];
           if (j >= 1 && normalized[i] < pair.fromCoord) {
             let prev = segment.correspondence[j - 1];
-            normalized[i] = ((normalized[i] - prev.fromCoord) * (pair.toCoord - prev.toCoord) + Number.EPSILON) /
-              (pair.fromCoord - prev.fromCoord + Number.EPSILON) +
-              prev.toCoord;
+            normalized[i] = ((normalized[i] - prev.fromCoord) * (pair.toCoord - prev.toCoord) + Number.EPSILON)
+              / (pair.fromCoord - prev.fromCoord + Number.EPSILON)
+              + prev.toCoord;
 
             break;
           }
@@ -63,6 +86,11 @@ export default class GlyphVariationProcessor {
     return normalized;
   }
 
+  /**
+   * @param {number} gid
+   * @param {GlyphPoint[]} glyphPoints
+   * @returns {void}
+   */
   transformPoints(gid, glyphPoints) {
     if (!this.font.fvar || !this.font.gvar) { return; }
 
@@ -82,10 +110,12 @@ export default class GlyphVariationProcessor {
     let tupleCount = stream.readUInt16BE();
     let offsetToData = offset + stream.readUInt16BE();
 
+    /** @type {Uint16Array} */
+    let sharedPoints = new Uint16Array(0);
     if (tupleCount & TUPLES_SHARE_POINT_NUMBERS) {
       let here = stream.pos;
       stream.pos = offsetToData;
-      var sharedPoints = this.decodePoints();
+      sharedPoints = this.decodePoints();
       offsetToData = stream.pos;
       stream.pos = here;
     }
@@ -97,13 +127,13 @@ export default class GlyphVariationProcessor {
       let tupleDataSize = stream.readUInt16BE();
       let tupleIndex = stream.readUInt16BE();
 
+      /** @type {number[]} */
       let tupleCoords;
       if (tupleIndex & EMBEDDED_TUPLE_COORD) {
         tupleCoords = [];
         for (let a = 0; a < gvar.axisCount; a++) {
           tupleCoords.push(stream.readInt16BE() / 16384);
         }
-
       } else {
         if ((tupleIndex & TUPLE_INDEX_MASK) >= gvar.globalCoordCount) {
           throw new Error('Invalid gvar table');
@@ -112,13 +142,17 @@ export default class GlyphVariationProcessor {
         tupleCoords = gvar.globalCoords[tupleIndex & TUPLE_INDEX_MASK];
       }
 
+      /** @type {number[] | undefined} */
+      let startCoords;
+      /** @type {number[] | undefined} */
+      let endCoords;
       if (tupleIndex & INTERMEDIATE_TUPLE) {
-        var startCoords = [];
+        startCoords = [];
         for (let a = 0; a < gvar.axisCount; a++) {
           startCoords.push(stream.readInt16BE() / 16384);
         }
 
-        var endCoords = [];
+        endCoords = [];
         for (let a = 0; a < gvar.axisCount; a++) {
           endCoords.push(stream.readInt16BE() / 16384);
         }
@@ -134,6 +168,7 @@ export default class GlyphVariationProcessor {
       let here = stream.pos;
       stream.pos = offsetToData;
 
+      /** @type {Uint16Array} */
       let points;
       if (tupleIndex & PRIVATE_POINT_NUMBERS) {
         points = this.decodePoints();
@@ -147,34 +182,34 @@ export default class GlyphVariationProcessor {
       let yDeltas = this.decodeDeltas(nPoints);
 
       if (points.length === 0) { // all points
-        for (let i = 0; i < glyphPoints.length; i++) {
-          var point = glyphPoints[i];
-          point.x += Math.round(xDeltas[i] * factor);
-          point.y += Math.round(yDeltas[i] * factor);
+        for (let pi = 0; pi < glyphPoints.length; pi++) {
+          let point = glyphPoints[pi];
+          point.x += Math.round(xDeltas[pi] * factor);
+          point.y += Math.round(yDeltas[pi] * factor);
         }
       } else {
         let outPoints = origPoints.map(pt => pt.copy());
         let hasDelta = glyphPoints.map(() => false);
 
-        for (let i = 0; i < points.length; i++) {
-          let idx = points[i];
+        for (let pi = 0; pi < points.length; pi++) {
+          let idx = points[pi];
           if (idx < glyphPoints.length) {
             let point = outPoints[idx];
             hasDelta[idx] = true;
 
-            point.x += xDeltas[i] * factor;
-            point.y += yDeltas[i] * factor;
+            point.x += xDeltas[pi] * factor;
+            point.y += yDeltas[pi] * factor;
           }
         }
 
         this.interpolateMissingDeltas(outPoints, origPoints, hasDelta);
 
-        for (let i = 0; i < glyphPoints.length; i++) {
-          let deltaX = outPoints[i].x - origPoints[i].x;
-          let deltaY = outPoints[i].y - origPoints[i].y;
+        for (let pi = 0; pi < glyphPoints.length; pi++) {
+          let deltaX = outPoints[pi].x - origPoints[pi].x;
+          let deltaY = outPoints[pi].y - origPoints[pi].y;
 
-          glyphPoints[i].x = Math.round(glyphPoints[i].x + deltaX);
-          glyphPoints[i].y = Math.round(glyphPoints[i].y + deltaY);
+          glyphPoints[pi].x = Math.round(glyphPoints[pi].x + deltaX);
+          glyphPoints[pi].y = Math.round(glyphPoints[pi].y + deltaY);
         }
       }
 
@@ -183,6 +218,9 @@ export default class GlyphVariationProcessor {
     }
   }
 
+  /**
+   * @returns {Uint16Array}
+   */
   decodePoints() {
     let stream = this.font.stream;
     let count = stream.readUInt8();
@@ -197,7 +235,8 @@ export default class GlyphVariationProcessor {
     while (i < count) {
       let run = stream.readUInt8();
       let runCount = (run & POINT_RUN_COUNT_MASK) + 1;
-      let fn = run & POINTS_ARE_WORDS ? stream.readUInt16 : stream.readUInt8;
+      // gvar point numbers are big-endian (OpenType); was incorrectly readUInt16.
+      let fn = run & POINTS_ARE_WORDS ? stream.readUInt16BE : stream.readUInt8;
 
       for (let j = 0; j < runCount && i < count; j++) {
         point += fn.call(stream);
@@ -208,6 +247,10 @@ export default class GlyphVariationProcessor {
     return points;
   }
 
+  /**
+   * @param {number} count
+   * @returns {Int16Array}
+   */
   decodeDeltas(count) {
     let stream = this.font.stream;
     let i = 0;
@@ -219,7 +262,6 @@ export default class GlyphVariationProcessor {
 
       if (run & DELTAS_ARE_ZERO) {
         i += runCount;
-
       } else {
         let fn = run & DELTAS_ARE_WORDS ? stream.readInt16BE : stream.readInt8;
         for (let j = 0; j < runCount && i < count; j++) {
@@ -231,9 +273,19 @@ export default class GlyphVariationProcessor {
     return deltas;
   }
 
+  /**
+   * @param {number} tupleIndex
+   * @param {number[]} tupleCoords
+   * @param {number[] | undefined} startCoords
+   * @param {number[] | undefined} endCoords
+   * @returns {number}
+   */
   tupleFactor(tupleIndex, tupleCoords, startCoords, endCoords) {
     let normalized = this.normalizedCoords;
     let { gvar } = this.font;
+    if (!gvar) {
+      return 0;
+    }
     let factor = 1;
 
     for (let i = 0; i < gvar.axisCount; i++) {
@@ -246,20 +298,21 @@ export default class GlyphVariationProcessor {
       }
 
       if ((tupleIndex & INTERMEDIATE_TUPLE) === 0) {
-        if ((normalized[i] < Math.min(0, tupleCoords[i])) ||
-            (normalized[i] > Math.max(0, tupleCoords[i]))) {
+        if ((normalized[i] < Math.min(0, tupleCoords[i]))
+          || (normalized[i] > Math.max(0, tupleCoords[i]))) {
           return 0;
         }
 
         factor = (factor * normalized[i] + Number.EPSILON) / (tupleCoords[i] + Number.EPSILON);
       } else {
-        if ((normalized[i] < startCoords[i]) ||
-            (normalized[i] > endCoords[i])) {
+        if (!startCoords || !endCoords) {
+          return 0;
+        }
+        if ((normalized[i] < startCoords[i])
+          || (normalized[i] > endCoords[i])) {
           return 0;
-
         } else if (normalized[i] < tupleCoords[i]) {
           factor = factor * (normalized[i] - startCoords[i] + Number.EPSILON) / (tupleCoords[i] - startCoords[i] + Number.EPSILON);
-
         } else {
           factor = factor * (endCoords[i] - normalized[i] + Number.EPSILON) / (endCoords[i] - tupleCoords[i] + Number.EPSILON);
         }
@@ -269,9 +322,15 @@ export default class GlyphVariationProcessor {
     return factor;
   }
 
-  // Interpolates points without delta values.
-  // Needed for the Ø and Q glyphs in Skia.
-  // Algorithm from Freetype.
+  /**
+   * Interpolates points without delta values.
+   * Needed for the Ø and Q glyphs in Skia.
+   * Algorithm from Freetype.
+   * @param {GlyphPoint[]} points
+   * @param {GlyphPoint[]} inPoints
+   * @param {boolean[]} hasDelta
+   * @returns {void}
+   */
   interpolateMissingDeltas(points, inPoints, hasDelta) {
     if (points.length === 0) {
       return;
@@ -327,24 +386,36 @@ export default class GlyphVariationProcessor {
     }
   }
 
+  /**
+   * @param {number} p1
+   * @param {number} p2
+   * @param {number} ref1
+   * @param {number} ref2
+   * @param {GlyphPoint[]} inPoints
+   * @param {GlyphPoint[]} outPoints
+   * @returns {void}
+   */
   deltaInterpolate(p1, p2, ref1, ref2, inPoints, outPoints) {
     if (p1 > p2) {
       return;
     }
 
+    /** @type {Array<'x' | 'y'>} */
     let iterable = ['x', 'y'];
     for (let i = 0; i < iterable.length; i++) {
       let k = iterable[i];
-      if (inPoints[ref1][k] > inPoints[ref2][k]) {
-        var p = ref1;
-        ref1 = ref2;
-        ref2 = p;
+      let r1 = ref1;
+      let r2 = ref2;
+      if (inPoints[r1][k] > inPoints[r2][k]) {
+        let p = r1;
+        r1 = r2;
+        r2 = p;
       }
 
-      let in1 = inPoints[ref1][k];
-      let in2 = inPoints[ref2][k];
-      let out1 = outPoints[ref1][k];
-      let out2 = outPoints[ref2][k];
+      let in1 = inPoints[r1][k];
+      let in2 = inPoints[r2][k];
+      let out1 = outPoints[r1][k];
+      let out2 = outPoints[r2][k];
 
       // If the reference points have the same coordinate but different
       // delta, inferred delta is zero.  Otherwise interpolate.
@@ -368,6 +439,14 @@ export default class GlyphVariationProcessor {
     }
   }
 
+  /**
+   * @param {number} p1
+   * @param {number} p2
+   * @param {number} ref
+   * @param {GlyphPoint[]} inPoints
+   * @param {GlyphPoint[]} outPoints
+   * @returns {void}
+   */
   deltaShift(p1, p2, ref, inPoints, outPoints) {
     let deltaX = outPoints[ref].x - inPoints[ref].x;
     let deltaY = outPoints[ref].y - inPoints[ref].y;
@@ -384,6 +463,11 @@ export default class GlyphVariationProcessor {
     }
   }
 
+  /**
+   * @param {number} gid
+   * @param {HVARTable} table
+   * @returns {number}
+   */
   getAdvanceAdjustment(gid, table) {
     let outerIndex, innerIndex;
 
@@ -393,7 +477,7 @@ export default class GlyphVariationProcessor {
         idx = table.advanceWidthMapping.mapCount - 1;
       }
 
-      ({outerIndex, innerIndex} = table.advanceWidthMapping.mapData[idx]);
+      ({ outerIndex, innerIndex } = table.advanceWidthMapping.mapData[idx]);
     } else {
       outerIndex = 0;
       innerIndex = gid;
@@ -402,8 +486,14 @@ export default class GlyphVariationProcessor {
     return this.getDelta(table.itemVariationStore, outerIndex, innerIndex);
   }
 
-  // See pseudo code from `Font Variations Overview'
-  // in the OpenType specification.
+  /**
+   * See pseudo code from `Font Variations Overview'
+   * in the OpenType specification.
+   * @param {ItemVariationStore} itemStore
+   * @param {number} outerIndex
+   * @param {number} innerIndex
+   * @returns {number}
+   */
   getDelta(itemStore, outerIndex, innerIndex) {
     if (outerIndex >= itemStore.itemVariationData.length) {
       return 0;
@@ -425,13 +515,20 @@ export default class GlyphVariationProcessor {
     return netAdjustment;
   }
 
+  /**
+   * @param {ItemVariationStore} itemStore
+   * @param {number} outerIndex
+   * @returns {number[]}
+   */
   getBlendVector(itemStore, outerIndex) {
     let varData = itemStore.itemVariationData[outerIndex];
-    if (this.blendVectors.has(varData)) {
-      return this.blendVectors.get(varData);
+    let cached = this.blendVectors.get(varData);
+    if (cached) {
+      return cached;
     }
 
     let normalizedCoords = this.normalizedCoords;
+    /** @type {number[]} */
     let blendVector = [];
 
     // outer loop steps through master designs to be blended
@@ -449,7 +546,6 @@ export default class GlyphVariationProcessor {
         // ignore invalid ranges
         if (axis.startCoord > axis.peakCoord || axis.peakCoord > axis.endCoord) {
           axisScalar = 1;
-
         } else if (axis.startCoord < 0 && axis.endCoord > 0 && axis.peakCoord !== 0) {
           axisScalar = 1;
 
@@ -466,11 +562,11 @@ export default class GlyphVariationProcessor {
           if (normalizedCoords[j] === axis.peakCoord) {
             axisScalar = 1;
           } else if (normalizedCoords[j] < axis.peakCoord) {
-            axisScalar = (normalizedCoords[j] - axis.startCoord + Number.EPSILON) /
-              (axis.peakCoord - axis.startCoord + Number.EPSILON);
+            axisScalar = (normalizedCoords[j] - axis.startCoord + Number.EPSILON)
+              / (axis.peakCoord - axis.startCoord + Number.EPSILON);
           } else {
-            axisScalar = (axis.endCoord - normalizedCoords[j] + Number.EPSILON) /
-              (axis.endCoord - axis.peakCoord + Number.EPSILON);
+            axisScalar = (axis.endCoord - normalizedCoords[j] + Number.EPSILON)
+              / (axis.endCoord - axis.peakCoord + Number.EPSILON);
           }
         }