@cantoo/fontkit 2.0.5 → 2.0.6

package/src/opentype/GlyphInfo.js

@@ -1,36 +1,79 @@
 import { isMark } from '../packages/unicode-properties/index.js';
 import OTProcessor from './OTProcessor';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').FeatureInput} FeatureInput */
+/** @typedef {import('../../types/fontkit').ClassDefTable} ClassDefTable */
+
 export default class GlyphInfo {
+  /**
+   * @param {LayoutFont} font
+   * @param {number} id
+   * @param {number[]} [codePoints]
+   * @param {FeatureInput | null | undefined} [features]
+   */
   constructor(font, id, codePoints = [], features) {
+    /** @type {LayoutFont} */
     this._font = font;
+    /** @type {number[]} */
     this.codePoints = codePoints;
-    this.id = id;
+    /** @type {number} */
+    this._id = 0;
 
+    /** @type {FeatureMap} */
     this.features = {};
     if (Array.isArray(features)) {
       for (let i = 0; i < features.length; i++) {
         let feature = features[i];
         this.features[feature] = true;
       }
-    } else if (typeof features === 'object') {
+    } else if (typeof features === 'object' && features !== null) {
       Object.assign(this.features, features);
     }
 
+    /** @type {number | null} */
     this.ligatureID = null;
+    /** @type {number | null} */
     this.ligatureComponent = null;
+    /** @type {boolean} */
     this.isLigated = false;
+    /** @type {number | null} */
     this.cursiveAttachment = null;
+    /** @type {number | null} */
     this.markAttachment = null;
+    /** @type {import('../../types/fontkit').IndicShaperInfo | import('../../types/fontkit').USEShaperInfo | null} */
     this.shaperInfo = null;
+    /** @type {boolean} */
     this.substituted = false;
+    /** @type {boolean} */
     this.isMultiplied = false;
+
+    /** @type {boolean} */
+    this.isBase = false;
+    /** @type {boolean} */
+    this.isLigature = false;
+    /** @type {boolean} */
+    this.isMark = false;
+    /** @type {number} */
+    this.markAttachmentType = 0;
+
+    // Apply GDEF / mark classification via the id setter, then clear
+    // `substituted` — construction is not a GSUB substitution.
+    this.id = id;
+    this.substituted = false;
   }
 
+  /**
+   * @returns {number}
+   */
   get id() {
     return this._id;
   }
 
+  /**
+   * @param {number} id
+   */
   set id(id) {
     this._id = id;
     this.substituted = true;
@@ -38,11 +81,13 @@ export default class GlyphInfo {
     let GDEF = this._font.GDEF;
     if (GDEF && GDEF.glyphClassDef) {
       // TODO: clean this up
-      let classID = OTProcessor.prototype.getClassID(id, GDEF.glyphClassDef);
+      let classID = OTProcessor.prototype.getClassID(id, /** @type {ClassDefTable} */ (GDEF.glyphClassDef));
       this.isBase = classID === 1;
       this.isLigature = classID === 2;
       this.isMark = classID === 3;
-      this.markAttachmentType = GDEF.markAttachClassDef ? OTProcessor.prototype.getClassID(id, GDEF.markAttachClassDef) : 0;
+      this.markAttachmentType = GDEF.markAttachClassDef
+        ? OTProcessor.prototype.getClassID(id, /** @type {ClassDefTable} */ (GDEF.markAttachClassDef))
+        : 0;
     } else {
       this.isMark = this.codePoints.length > 0 && this.codePoints.every(isMark);
       this.isBase = !this.isMark;
@@ -51,6 +96,9 @@ export default class GlyphInfo {
     }
   }
 
+  /**
+   * @returns {GlyphInfo}
+   */
   copy() {
     return new GlyphInfo(this._font, this.id, this.codePoints, this.features);
   }

package/src/opentype/GlyphIterator.js

@@ -1,21 +1,48 @@
+/** @typedef {import('../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../types/fontkit').GlyphIteratorOptions} GlyphIteratorOptions */
+/** @typedef {import('../../types/fontkit').LookupFlags} LookupFlags */
+/** @typedef {import('../../types/fontkit').MarkFilteringSet} MarkFilteringSet */
+
 export default class GlyphIterator {
+  /**
+   * @param {GlyphInfoLike[]} glyphs
+   * @param {GlyphIteratorOptions} [options]
+   */
   constructor(glyphs, options) {
+    /** @type {GlyphInfoLike[]} */
     this.glyphs = glyphs;
     this.reset(options);
   }
 
+  /**
+   * @param {GlyphIteratorOptions} [options]
+   * @param {number} [index]
+   * @param {MarkFilteringSet | null} [markFilteringSet]
+   */
   reset(options = {}, index = 0, markFilteringSet = null) {
+    /** @type {GlyphIteratorOptions} */
     this.options = options;
+    /** @type {LookupFlags} */
     this.flags = options.flags || {};
+    /** @type {number} */
     this.markAttachmentType = options.markAttachmentType || 0;
+    /** @type {MarkFilteringSet | null} */
     this.markFilteringSet = markFilteringSet;
+    /** @type {number} */
     this.index = index;
   }
 
+  /**
+   * @returns {GlyphInfoLike | null}
+   */
   get cur() {
     return this.glyphs[this.index] || null;
   }
 
+  /**
+   * @param {GlyphInfoLike} glyph
+   * @returns {boolean}
+   */
   shouldIgnore(glyph) {
     // Mark skip hierarchy (OT chapter 2): ignoreMarks > mark filtering set > markAttachmentType.
     if (glyph.isMark) {
@@ -30,10 +57,14 @@ export default class GlyphIterator {
       }
     }
 
-    return (this.flags.ignoreBaseGlyphs && glyph.isBase)
-      || (this.flags.ignoreLigatures && glyph.isLigature);
+    return !!(this.flags.ignoreBaseGlyphs && glyph.isBase)
+      || !!(this.flags.ignoreLigatures && glyph.isLigature);
   }
 
+  /**
+   * @param {number} dir
+   * @returns {GlyphInfoLike | null}
+   */
   move(dir) {
     this.index += dir;
     while (0 <= this.index && this.index < this.glyphs.length && this.shouldIgnore(this.glyphs[this.index])) {
@@ -47,14 +78,24 @@ export default class GlyphIterator {
     return this.glyphs[this.index];
   }
 
+  /**
+   * @returns {GlyphInfoLike | null}
+   */
   next() {
     return this.move(+1);
   }
 
+  /**
+   * @returns {GlyphInfoLike | null}
+   */
   prev() {
     return this.move(-1);
   }
 
+  /**
+   * @param {number} [count]
+   * @returns {GlyphInfoLike | undefined}
+   */
   peek(count = 1) {
     let idx = this.index;
     let res = this.increment(count);
@@ -62,6 +103,10 @@ export default class GlyphIterator {
     return res;
   }
 
+  /**
+   * @param {number} [count]
+   * @returns {number}
+   */
   peekIndex(count = 1) {
     let idx = this.index;
     this.increment(count);
@@ -70,6 +115,10 @@ export default class GlyphIterator {
     return res;
   }
 
+  /**
+   * @param {number} [count]
+   * @returns {GlyphInfoLike | undefined}
+   */
   increment(count = 1) {
     let dir = count < 0 ? -1 : 1;
     count = Math.abs(count);

package/src/opentype/OTLayoutEngine.js

@@ -4,14 +4,35 @@ import GlyphInfo from './GlyphInfo';
 import GSUBProcessor from './GSUBProcessor';
 import GPOSProcessor from './GPOSProcessor';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').GlyphRunLike} GlyphRunLike */
+/** @typedef {import('../../types/fontkit').GlyphInfoLike} GlyphInfoLike */
+/** @typedef {import('../../types/fontkit').GlyphPositionLike} GlyphPositionLike */
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').ScriptTag} ScriptTag */
+/** @typedef {import('../../types/fontkit').LanguageTag} LanguageTag */
+/** @typedef {import('../../types/fontkit').LayoutGlyph} LayoutGlyph */
+/** @typedef {import('../../types/fontkit').ShaperLike} ShaperLike */
+
 export default class OTLayoutEngine {
+  /**
+   * @param {LayoutFont} font
+   */
   constructor(font) {
+    /** @type {LayoutFont} */
     this.font = font;
+    /** @type {GlyphInfo[] | null} */
     this.glyphInfos = null;
+    /** @type {ShapingPlan | null} */
     this.plan = null;
+    /** @type {GSUBProcessor | null} */
     this.GSUBProcessor = null;
+    /** @type {GPOSProcessor | null} */
     this.GPOSProcessor = null;
+    /** @type {boolean} */
     this.fallbackPosition = true;
+    /** @type {ShaperLike | null} */
+    this.shaper = null;
 
     if (font.GSUB) {
       this.GSUBProcessor = new GSUBProcessor(font, font.GSUB);
@@ -22,12 +43,18 @@ export default class OTLayoutEngine {
     }
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   */
   setup(glyphRun) {
     // Map glyphs to GlyphInfo objects so data can be passed between
     // GSUB and GPOS without mutating the real (shared) Glyph objects.
-    this.glyphInfos = glyphRun.glyphs.map(glyph => new GlyphInfo(this.font, glyph.id, [...glyph.codePoints]));
+    this.glyphInfos = /** @type {LayoutGlyph[]} */ (glyphRun.glyphs).map(
+      /** @param {LayoutGlyph} glyph */ glyph => new GlyphInfo(this.font, glyph.id, [...glyph.codePoints])
+    );
 
     // Select an OpenType script for GSUB/GPOS features.
+    /** @type {string | null} */
     let script = null;
     if (this.GPOSProcessor) {
       script = this.GPOSProcessor.selectScript(glyphRun.script, glyphRun.language, glyphRun.direction);
@@ -40,12 +67,13 @@ export default class OTLayoutEngine {
     // Choose the complex shaper from the buffer Unicode script (HB model). The OT
     // script may fall back to DFLT/latn even for Thai text; that must not select
     // DefaultShaper or Thai SARA AM / PUA preprocessing is skipped.
-    this.shaper = Shapers.choose(glyphRun.script || script);
+    this.shaper = /** @type {ShaperLike} */ (Shapers.choose(glyphRun.script || script));
     this.plan = new ShapingPlan(this.font, script || glyphRun.script, glyphRun.direction);
     this.plan.bufferScript = glyphRun.script;
     this.shaper.plan(this.plan, this.glyphInfos, glyphRun.features);
 
     // Enabled features as true, then overlay user values (e.g. aalt: 2) without mutating input.
+    /** @type {FeatureMap} */
     let features = {};
     for (let key in this.plan.allFeatures) {
       features[key] = true;
@@ -53,38 +81,62 @@ export default class OTLayoutEngine {
     glyphRun.features = Object.assign(features, glyphRun.features);
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   */
   substitute(glyphRun) {
-    if (this.GSUBProcessor) {
+    if (this.GSUBProcessor && this.plan && this.glyphInfos) {
       this.plan.process(this.GSUBProcessor, this.glyphInfos);
 
       // Map glyph infos back to normal Glyph objects
-      glyphRun.glyphs = this.glyphInfos.map(glyphInfo => this.font.getGlyph(glyphInfo.id, glyphInfo.codePoints));
+      /** @type {LayoutGlyph[]} */
+      let glyphs = [];
+      for (let glyphInfo of this.glyphInfos) {
+        let g = this.font.getGlyph(glyphInfo.id, glyphInfo.codePoints);
+        if (g) {
+          glyphs.push(g);
+        }
+      }
+      glyphRun.glyphs = glyphs;
     }
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   * @returns {FeatureMap | Record<string, import('../../types/fontkit').OTFeature> | null | undefined | false}
+   */
   position(glyphRun) {
-    if (this.shaper.zeroMarkWidths === 'BEFORE_GPOS') {
+    if (this.shaper && this.shaper.zeroMarkWidths === 'BEFORE_GPOS' && glyphRun.positions) {
       this.zeroMarkAdvances(glyphRun.positions);
     }
 
-    if (this.GPOSProcessor) {
+    if (this.GPOSProcessor && this.plan && this.glyphInfos && glyphRun.positions) {
       this.plan.process(this.GPOSProcessor, this.glyphInfos, glyphRun.positions);
     }
 
-    if (this.shaper.zeroMarkWidths === 'AFTER_GPOS') {
+    if (this.shaper && this.shaper.zeroMarkWidths === 'AFTER_GPOS' && glyphRun.positions) {
       this.zeroMarkAdvances(glyphRun.positions);
     }
 
     // Reverse the glyphs and positions if the script is right-to-left
     if (glyphRun.direction === 'rtl') {
       glyphRun.glyphs.reverse();
-      glyphRun.positions.reverse();
+      if (glyphRun.positions) {
+        glyphRun.positions.reverse();
+      }
     }
 
     return this.GPOSProcessor && this.GPOSProcessor.features;
   }
 
+  /**
+   * @param {GlyphPositionLike[]} positions
+   */
   zeroMarkAdvances(positions) {
+    if (!this.glyphInfos) {
+      return;
+    }
+
     for (let i = 0; i < this.glyphInfos.length; i++) {
       if (this.glyphInfos[i].isMark) {
         positions[i].xAdvance = 0;
@@ -99,7 +151,13 @@ export default class OTLayoutEngine {
     this.shaper = null;
   }
 
+  /**
+   * @param {ScriptTag | string[] | null | undefined} script
+   * @param {LanguageTag | null | undefined} language
+   * @returns {string[]}
+   */
   getAvailableFeatures(script, language) {
+    /** @type {string[]} */
     let features = [];
 
     if (this.GSUBProcessor) {