@cantoo/fontkit 2.0.4 → 2.0.6

package/src/aat/AATFeatureMap.js

@@ -1,5 +1,15 @@
 // see https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html
 // and /System/Library/Frameworks/CoreText.framework/Versions/A/Headers/SFNTLayoutTypes.h on a Mac
+
+/** @typedef {import('../../types/fontkit').FeatureMap} FeatureMap */
+/** @typedef {import('../../types/fontkit').FeatureValue} FeatureValue */
+/** @typedef {import('../../types/fontkit').AATFeatureSettings} AATFeatureSettings */
+
+/**
+ * @typedef {{ code: number, exclusive: boolean, [selector: string]: number | boolean }} AATFeatureDef
+ */
+
+/** @type {Record<string, AATFeatureDef>} */
 const features = {
   allTypographicFeatures: {
     code: 0,
@@ -32,12 +42,12 @@ const features = {
     code: 3,
     exclusive: true
   },
-    // upperAndLowerCase: 0          # deprecated
-    // allCaps: 1                    # deprecated
-    // allLowerCase: 2               # deprecated
-    // smallCaps: 3                  # deprecated
-    // initialCaps: 4                # deprecated
-    // initialCapsAndSmallCaps: 5    # deprecated
+  // upperAndLowerCase: 0          # deprecated
+  // allCaps: 1                    # deprecated
+  // allLowerCase: 2               # deprecated
+  // smallCaps: 3                  # deprecated
+  // initialCaps: 4                # deprecated
+  // initialCapsAndSmallCaps: 5    # deprecated
   verticalSubstitution: {
     code: 4,
     exclusive: false,
@@ -100,9 +110,9 @@ const features = {
     // hyphenToEnDash: 2
     slashedZero: 4
   },
-    // formInterrobang: 6
-    // smartQuotes: 8
-    // periodsToEllipsis: 10
+  // formInterrobang: 6
+  // smartQuotes: 8
+  // periodsToEllipsis: 10
   mathematicalExtras: {
     code: 15,
     exclusive: false,
@@ -129,7 +139,7 @@ const features = {
     exclusive: true,
     noAlternates: 0
   },
-    // user defined options
+  // user defined options
   designComplexity: {
     code: 18,
     exclusive: true,
@@ -190,15 +200,15 @@ const features = {
     exclusive: true,
     noTransliteration: 0
   },
-    // hanjaToHangul: 1
-    // hiraganaToKatakana: 2
-    // katakanaToHiragana: 3
-    // kanaToRomanization: 4
-    // romanizationToHiragana: 5
-    // romanizationToKatakana: 6
-    // hanjaToHangulAltOne: 7
-    // hanjaToHangulAltTwo: 8
-    // hanjaToHangulAltThree: 9
+  // hanjaToHangul: 1
+  // hiraganaToKatakana: 2
+  // katakanaToHiragana: 3
+  // kanaToRomanization: 4
+  // romanizationToHiragana: 5
+  // romanizationToKatakana: 6
+  // hanjaToHangulAltOne: 7
+  // hanjaToHangulAltTwo: 8
+  // hanjaToHangulAltThree: 9
   annotation: {
     code: 24,
     exclusive: true,
@@ -346,8 +356,17 @@ const features = {
   }
 };
 
-const feature = (name, selector) => [features[name].code, features[name][selector]];
+/**
+ * @param {string} name
+ * @param {string} selector
+ * @returns {[number, number]}
+ */
+const feature = (name, selector) => {
+  let f = features[name];
+  return [(f.code), /** @type {number} */ (f[selector])];
+};
 
+/** @type {Record<string, [number, number]>} */
 const OTMapping = {
   rlig: feature('ligatures', 'requiredLigatures'),
   clig: feature('ligatures', 'contextualLigatures'),
@@ -418,7 +437,7 @@ const OTMapping = {
   hwid: feature('textSpacing', 'halfWidthText'),
   qwid: feature('textSpacing', 'quarterWidthText'), // also QuarterWidthNumbers?
   twid: feature('textSpacing', 'thirdWidthText'), // also ThirdWidthNumbers?
-  fwid: feature('textSpacing', 'proportionalText'), //??
+  fwid: feature('textSpacing', 'proportionalText'), // ??
   palt: feature('textSpacing', 'altProportionalText'),
   trad: feature('characterShape', 'traditionalCharacters'),
   smpl: feature('characterShape', 'simplifiedCharacters'),
@@ -456,14 +475,14 @@ const OTMapping = {
   ss20: feature('stylisticAlternatives', 'stylisticAltTwenty')
 };
 
-  // salt: feature 'stylisticAlternatives', 'stylisticAltOne' # hmm, which one to choose
+// salt: feature 'stylisticAlternatives', 'stylisticAltOne' # hmm, which one to choose
 
 // Add cv01-cv99 features
 for (let i = 1; i <= 99; i++) {
   OTMapping[`cv${`00${i}`.slice(-2)}`] = [features.characterAlternatives.code, i];
 }
 
-// create inverse mapping
+/** @type {Record<number, Record<number, string>>} */
 let AATMapping = {};
 for (let ot in OTMapping) {
   let aat = OTMapping[ot];
@@ -474,9 +493,14 @@ for (let ot in OTMapping) {
   AATMapping[aat[0]][aat[1]] = ot;
 }
 
-// Maps an array of OpenType features to AAT features
-// in the form of {featureType:{featureSetting:true}}
+/**
+ * Maps an OpenType feature map to AAT features
+ * in the form of {featureType:{featureSetting:true}}
+ * @param {FeatureMap | Record<string, FeatureValue>} features
+ * @returns {AATFeatureSettings}
+ */
 export function mapOTToAAT(features) {
+  /** @type {AATFeatureSettings} */
   let res = {};
   for (let k in features) {
     let r;
@@ -492,49 +516,68 @@ export function mapOTToAAT(features) {
   return res;
 }
 
-// Maps strings in a [featureType, featureSetting]
-// to their equivalent number codes
+/**
+ * @param {string | number} value
+ * @returns {value is string}
+ */
+function isFeatureName(value) {
+  return typeof value === 'string' && Number.isNaN(Number(value));
+}
+
+/**
+ * Maps strings in a [featureType, featureSetting]
+ * to their equivalent number codes
+ * @param {[string | number, string | number]} f
+ * @returns {[number | undefined, number | undefined]}
+ */
 function mapFeatureStrings(f) {
   let [type, setting] = f;
+  /** @type {number | undefined} */
   let typeCode;
-  if (isNaN(type)) {
-    typeCode = features[type] && features[type].code;
+  if (isFeatureName(type)) {
+    typeCode = features[type] && /** @type {number} */ (features[type].code);
   } else {
-    typeCode = type;
+    typeCode = Number(type);
   }
 
+  /** @type {number | undefined} */
   let settingCode;
-  if (isNaN(setting)) {
-    settingCode = features[type] && features[type][setting];
+  if (isFeatureName(setting)) {
+    let feat = isFeatureName(type) ? features[type] : undefined;
+    settingCode = feat ? /** @type {number} */ (feat[setting]) : undefined;
   } else {
-    settingCode = setting;
+    settingCode = Number(setting);
   }
 
   return [typeCode, settingCode];
 }
 
-// Maps AAT features to an array of OpenType features
-// Supports both arrays in the form of [[featureType, featureSetting]]
-// and objects in the form of {featureType:{featureSetting:true}}
-// featureTypes and featureSettings can be either strings or number codes
+/**
+ * Maps AAT features to an array of OpenType features.
+ * Supports both arrays in the form of [[featureType, featureSetting]]
+ * and objects in the form of {featureType:{featureSetting:true}}.
+ * featureTypes and featureSettings can be either strings or number codes.
+ * @param {Array<[string | number, string | number]> | Record<string, Record<string, FeatureValue>>} features
+ * @returns {string[]}
+ */
 export function mapAATToOT(features) {
+  /** @type {Record<string, true>} */
   let res = {};
   if (Array.isArray(features)) {
     for (let k = 0; k < features.length; k++) {
       let r;
       let f = mapFeatureStrings(features[k]);
-      if ((r = AATMapping[f[0]] && AATMapping[f[0]][f[1]])) {
+      if (f[0] != null && f[1] != null && (r = AATMapping[f[0]] && AATMapping[f[0]][f[1]])) {
         res[r] = true;
       }
     }
-
   } else if (typeof features === 'object') {
     for (let type in features) {
       let feature = features[type];
       for (let setting in feature) {
         let r;
         let f = mapFeatureStrings([type, setting]);
-        if (feature[setting] && (r = AATMapping[f[0]] && AATMapping[f[0]][f[1]])) {
+        if (feature[setting] && f[0] != null && f[1] != null && (r = AATMapping[f[0]] && AATMapping[f[0]][f[1]])) {
           res[r] = true;
         }
       }

package/src/aat/AATLayoutEngine.js

@@ -1,13 +1,27 @@
 import * as AATFeatureMap from './AATFeatureMap';
 import AATMorxProcessor from './AATMorxProcessor';
 
+/** @typedef {import('../../types/fontkit').LayoutFont} LayoutFont */
+/** @typedef {import('../../types/fontkit').GlyphRunLike} GlyphRunLike */
+/** @typedef {import('../../types/fontkit').ScriptTag} ScriptTag */
+/** @typedef {import('../../types/fontkit').LanguageTag} LanguageTag */
+
 export default class AATLayoutEngine {
+  /**
+   * @param {LayoutFont} font
+   */
   constructor(font) {
+    /** @type {LayoutFont} */
     this.font = font;
+    /** @type {AATMorxProcessor} */
     this.morxProcessor = new AATMorxProcessor(font);
+    /** @type {boolean} */
     this.fallbackPosition = false;
   }
 
+  /**
+   * @param {GlyphRunLike} glyphRun
+   */
   substitute(glyphRun) {
     // AAT expects the glyphs to be in visual order prior to morx processing,
     // so reverse the glyphs if the script is right-to-left.
@@ -15,16 +29,28 @@ export default class AATLayoutEngine {
       glyphRun.glyphs.reverse();
     }
 
-    this.morxProcessor.process(glyphRun.glyphs, AATFeatureMap.mapOTToAAT(glyphRun.features));
+    this.morxProcessor.process(
+      /** @type {import('../../types/fontkit').LayoutGlyph[]} */ (glyphRun.glyphs),
+      AATFeatureMap.mapOTToAAT(glyphRun.features)
+    );
   }
 
+  /**
+   * @param {ScriptTag | string[] | null | undefined} [_script]
+   * @param {LanguageTag | null | undefined} [_language]
+   * @returns {string[]}
+   */
   getAvailableFeatures(_script, _language) {
     return AATFeatureMap.mapAATToOT(this.morxProcessor.getSupportedFeatures());
   }
 
+  /**
+   * @param {number} gid
+   * @returns {Set<string>}
+   */
   stringsForGlyph(gid) {
     let glyphStrings = this.morxProcessor.generateInputs(gid);
-    let result = new Set;
+    let result = new Set();
 
     for (let glyphs of glyphStrings) {
       this._addStrings(glyphs, 0, result, '');
@@ -33,6 +59,12 @@ export default class AATLayoutEngine {
     return result;
   }
 
+  /**
+   * @param {number[]} glyphs
+   * @param {number} index
+   * @param {Set<string>} strings
+   * @param {string} string
+   */
   _addStrings(glyphs, index, strings, string) {
     let codePoints = this.font._cmapProcessor.codePointsForGlyph(glyphs[index]);
 

package/src/aat/AATLookupTable.js

@@ -1,15 +1,27 @@
-import {cache} from '../decorators';
-import {range} from '../utils';
+import { cache } from '../decorators';
+import { range } from '../utils';
+
+/** @typedef {import('../../types/fontkit').AATLookupTableData} AATLookupTableData */
+/** @typedef {import('../../types/fontkit').AATUnboundedArray<number>} AATNumberArray */
+/** @typedef {import('../../types/fontkit').AATLookupSegmentSingle} AATLookupSegmentSingle */
 
 export default class AATLookupTable {
+  /**
+   * @param {AATLookupTableData} table
+   */
   constructor(table) {
+    /** @type {AATLookupTableData} */
     this.table = table;
   }
 
+  /**
+   * @param {number} glyph
+   * @returns {number | null | undefined}
+   */
   lookup(glyph) {
     switch (this.table.version) {
       case 0: // simple array format
-        return this.table.values.getItem(glyph);
+        return /** @type {AATNumberArray} */ (this.table.values).getItem(glyph);
 
       case 2: // segment format
       case 4: {
@@ -67,15 +79,20 @@ export default class AATLookupTable {
       }
 
       case 8: // lookup trimmed
-        return this.table.values[glyph - this.table.firstGlyph];
+        return /** @type {number[]} */ (this.table.values)[glyph - this.table.firstGlyph];
 
       default:
         throw new Error(`Unknown lookup table format: ${this.table.version}`);
     }
   }
 
+  /**
+   * @param {number} classValue
+   * @returns {number[]}
+   */
   @cache
   glyphsForValue(classValue) {
+    /** @type {number[]} */
     let res = [];
 
     switch (this.table.version) {
@@ -107,8 +124,9 @@ export default class AATLookupTable {
       }
 
       case 8: { // lookup trimmed
-        for (let i = 0; i < this.table.values.length; i++) {
-          if (this.table.values[i] === classValue) {
+        let values = /** @type {number[]} */ (this.table.values);
+        for (let i = 0; i < values.length; i++) {
+          if (values[i] === classValue) {
             res.push(this.table.firstGlyph + i);
           }
         }