harfbuzzjs 0.4.15 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "harfbuzzjs",
-  "version": "0.4.15",
+  "version": "0.5.0",
   "description": "Minimal version of HarfBuzz for JavaScript use",
   "main": "index.js",
   "scripts": {

package/test/index.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const { expect } = require('chai');
 let hb;
-let blob, face, font, buffer;
+let blob, face, font, buffer, fontFuncs;
 
 before(async function () {
   hb = await require('..');
@@ -13,7 +13,8 @@ afterEach(function () {
   if (face) face.destroy();
   if (font) font.destroy();
   if (buffer) buffer.destroy();
-  blob = face = font = buffer = undefined;
+  if (fontFuncs) fontFuncs.destroy();
+  blob = face = font = buffer = fontFuncs = undefined;
 });
 
 describe('Face', function () {
@@ -45,9 +46,177 @@ describe('Face', function () {
     face = hb.createFace(blob);
     expect(Object.keys(face.getAxisInfos())).to.have.lengthOf(0);
   });
+
+  it('getTableScriptTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getTableScriptTags('GSUB')).to.deep.equal(['DFLT', 'cyrl', 'dev2', 'deva', 'grek', 'latn']);
+    expect(face.getTableScriptTags('GPOS')).to.deep.equal(['DFLT', 'cyrl', 'dev2', 'deva', 'grek', 'latn']);
+  });
+
+  it('getTableFeatureTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getTableFeatureTags('GSUB')).to.deep.equal([
+      'aalt', 'abvs', 'akhn', 'blwf', 'blwf', 'blws', 'c2sc', 'case', 'ccmp', 'ccmp',
+      'ccmp', 'ccmp', 'cjct', 'cjct', 'dnom', 'frac', 'half', 'half', 'half', 'half',
+      'haln', 'liga', 'lnum', 'locl', 'locl', 'locl', 'locl', 'locl', 'locl', 'locl',
+      'locl', 'locl', 'locl', 'locl', 'locl', 'nukt', 'numr', 'onum', 'ordn', 'pnum',
+      'pres', 'pres', 'psts', 'rkrf', 'rphf', 'rtlm', 'salt', 'sinf', 'smcp', 'ss03',
+      'ss04', 'ss06', 'ss07', 'subs', 'sups', 'tnum', 'vatu', 'zero'
+    ]);
+    expect(face.getTableFeatureTags('GPOS')).to.deep.equal(['abvm', 'blwm', 'dist', 'kern', 'mark', 'mkmk']);
+  });
+
+  it('getScriptLanguageTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getScriptLanguageTags('GSUB', 1)).to.deep.equal(['MKD ', 'SRB ']);
+    expect(face.getScriptLanguageTags('GPOS', 5)).to.deep.equal([]);
+  });
+
+  it('getScriptLanguageTags returns tags for GPOS table', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansDevanagari-Regular.otf')));
+    face = hb.createFace(blob);
+    expect(face.getScriptLanguageTags('GPOS', 1)).to.deep.equal(['MAR ', 'NEP ', 'SAN ', 'SAT ']);
+  });
+
+  it('getLanguageFeatureTags returns tags for a font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getLanguageFeatureTags('GSUB', 1, 1)).to.deep.equal(['aalt', 'c2sc', 'case', 'ccmp', 'dnom', 'frac',
+      'liga', 'lnum', 'locl', 'numr', 'onum', 'ordn', 'pnum', 'rtlm', 'sinf', 'smcp', 'ss03', 'ss06', 'ss07', 'subs',
+      'sups', 'tnum', 'zero']);
+    expect(face.getLanguageFeatureTags('GPOS', 5, 5)).to.deep.equal([]);
+  });
+
+  it('getTableScriptTags, getScriptLanguageTags, and getLanguageFeatureTags all together', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
+    face = hb.createFace(blob);
+    let result = {};
+    face.getTableScriptTags('GSUB').forEach((script, scriptIndex) => {
+      result[script] = { 'dflt': face.getLanguageFeatureTags('GSUB', scriptIndex, 0xFFFF) };
+      face.getScriptLanguageTags('GSUB', scriptIndex).forEach((language, languageIndex) => {
+        result[script][language] = face.getLanguageFeatureTags('GSUB', scriptIndex, languageIndex);
+      });
+    });
+    expect(result).to.deep.equal({
+      'DFLT': {
+        'dflt': ['aalt', 'ccmp', 'dlig', 'fina', 'init', 'isol', 'medi']
+      },
+      'arab': {
+        'dflt': ['aalt', 'ccmp', 'dlig', 'fina', 'init', 'isol', 'medi', 'rlig'],
+        'URD ': ['aalt', 'ccmp', 'dlig', 'fina', 'init', 'isol', 'locl', 'medi']
+      }
+    });
+  });
+
+  it('listNames fetches all names', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    let names = face.listNames();
+    expect(names.length).to.equal(38);
+    expect(names[0]).to.deep.equal({ nameId: 0, language: 'en' });
+    expect(names[37]).to.deep.equal({ nameId: 278, language: 'en' });
+  })
+
+  it('getName fetches a name', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getName(1, 'en')).to.equal('Noto Sans');
+    expect(face.getName(256, 'en')).to.equal('florin symbol');
+  })
+
+  it('getFeatureNameIds returns valid name Ids for ssNN features', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("ss03"))).to.deep.equal({
+        uiLabelNameId: 256,
+        uiTooltipTextNameId: null,
+        sampleTextNameId: null,
+        paramUiLabelNameIds: []
+      });
+  })
+
+  it('getFeatureNameIds with getName', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getName(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("ss03")).uiLabelNameId, 'en')).to.equal('florin symbol');
+  })
+
+  it('getFeatureNameIds not found', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    expect(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("salt"))).to.equal(null);
+  })
+
+  it('getFeatureNameIds returns valid name Ids for cvNN features', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, '../harfbuzz/test/api/fonts/cv01.otf')));
+    face = hb.createFace(blob);
+    expect(face.getFeatureNameIds("GSUB",
+      face.getTableFeatureTags("GSUB").indexOf("cv01"))).to.deep.equal({
+        uiLabelNameId: 256,
+        uiTooltipTextNameId: 257,
+        sampleTextNameId: 258,
+        paramUiLabelNameIds: [259, 260]
+      });
+  })
 });
 
 describe('Font', function () {
+  it('subFont creates a sub font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    let subFont = font.subFont();
+    expect(subFont.ptr).to.not.equal(font.ptr);
+    subFont.destroy();
+  });
+
+  it('subFont font funcs fallback to parent', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    let subFont = font.subFont();
+    expect(subFont.ptr).to.not.equal(font.ptr);
+
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphNameFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(subFont.ptr);
+      return null;
+    });
+    subFont.setFuncs(fontFuncs);
+
+    expect(subFont.glyphName(20)).to.equal("gid20");
+    expect(subFont.glyphHAdvance(20)).to.equal(font.glyphHAdvance(20));
+    subFont.destroy();
+  });
+
+  it('hExtents returns extents for the font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.hExtents()).to.deep.equal({
+      ascender: 1069,
+      descender: -293,
+      lineGap: 0
+    });
+  });
+
+  it('vExtents returns extents for the font', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.vExtents()).to.deep.equal({
+      ascender: 0,
+      descender: 0,
+      lineGap: 0
+    });
+  });
+
   it('glyphName returns names for glyph ids', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
     face = hb.createFace(blob);
@@ -68,6 +237,54 @@ describe('Font', function () {
     expect(glyphs[0].ax).to.equal(561 * 2);
   });
 
+  it('glyphExtents returns extents for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphExtents(20)).to.deep.equal({
+      xBearing: 89,
+      yBearing: 714,
+      width: 266,
+      height: -714
+    });
+  });
+
+  it('glyphHAdvance returns advances for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphHAdvance(20)).to.equal(572);
+  });
+
+  it('glyphVAdvance returns advances for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphVAdvance(20)).to.equal(-1000);
+  });
+
+  it('glyphHOrigin returns origins for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphHOrigin(20)).to.deep.equal([0, 0]);
+  });
+
+  it('glyphVOrigin returns origins for glyph ids', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphVOrigin(20)).to.equal(null);
+  });
+
+  it('glyphFromName returns ids for glyph names', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    expect(font.glyphFromName('one')).to.equal(20);
+    expect(font.glyphFromName('NonExistentGlyph')).to.equal(null);
+  });
+
   it('setVariations affects advances', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
     face = hb.createFace(blob);
@@ -111,6 +328,206 @@ describe('Font', function () {
   });
 });
 
+describe('FontFuncs', function () {
+  it('setGlyphExtentsFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphExtentsFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return {
+        xBearing: glyph,
+        yBearing: 0,
+        width: 100 * glyph,
+        height: 100
+      };
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphExtents(0)).to.deep.equal({
+      xBearing: 0,
+      yBearing: 0,
+      width: 0,
+      height: 100
+    });
+    expect(font.glyphExtents(20)).to.deep.equal({
+      xBearing: 20,
+      yBearing: 0,
+      width: 2000,
+      height: 100
+    });
+  });
+
+  it('setGlyphFromNameFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphFromNameFunc(function (font_, name) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return name == 'one' ? 20 : null;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphFromName('one')).to.equal(20);
+    expect(font.glyphFromName('two')).to.equal(null);
+  });
+
+  it('setGlyphHAdvanceFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphHAdvanceFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? 100 : 200;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphHAdvance(20)).to.equal(100);
+    expect(font.glyphHAdvance(21)).to.equal(200);
+  });
+
+  it('setGlyphVAdvanceFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphVAdvanceFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? 100 : 200;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphVAdvance(20)).to.equal(100);
+    expect(font.glyphVAdvance(21)).to.equal(200);
+  });
+
+  it('setGlyphHOriginFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphHOriginFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? [100, 200] : [300, 400];
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphHOrigin(20)).to.deep.equal([100, 200]);
+    expect(font.glyphHOrigin(21)).to.deep.equal([300, 400]);
+  });
+
+  it('setGlyphVOriginFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphVOriginFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? [100, 200] : [300, 400];
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphVOrigin(20)).to.deep.equal([100, 200]);
+    expect(font.glyphVOrigin(21)).to.deep.equal([300, 400]);
+  });
+
+  it('setGlyphNameFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setGlyphNameFunc(function (font_, glyph) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return glyph == 20 ? 'one' : null;
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.glyphName(20)).to.equal('one');
+    expect(font.glyphName(21)).to.equal('gid21');
+  });
+
+  it('setNominalGlyphFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setNominalGlyphFunc(function (font_, unicode) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return unicode == 49 ? 21 : 22;
+    });
+    font.setFuncs(fontFuncs);
+    buffer = hb.createBuffer();
+    buffer.addText('12');
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0].g).to.equal(21);
+    expect(glyphs[1].g).to.equal(22);
+  });
+
+  it('setVariationGlyphFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setNominalGlyphFunc(function (font_, unicode) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return unicode == 49 ? 21 : 22;
+    });
+    fontFuncs.setVariationGlyphFunc(function (font_, unicode, variationSelector) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return unicode == 49 ? 23 : null;
+    });
+    font.setFuncs(fontFuncs);
+    buffer = hb.createBuffer();
+    buffer.addText('11\uFE002\uFE00');
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0].g).to.equal(21);
+    expect(glyphs[1].g).to.equal(23);
+    expect(glyphs[2].g).to.equal(22);
+  });
+
+  it('setFontHExtentsFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setFontHExtentsFunc(function (font_) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return {
+        ascender: 100,
+        descender: 200,
+        lineGap: 300,
+      };
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.hExtents()).to.deep.equal({
+      ascender: 100,
+      descender: 200,
+      lineGap: 300,
+    });
+  });
+
+  it('setFontVExtentsFunc', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    fontFuncs = hb.createFontFuncs();
+    fontFuncs.setFontVExtentsFunc(function (font_) {
+      expect(font_.ptr).to.equal(font.ptr);
+      return {
+        ascender: 100,
+        descender: 200,
+        lineGap: 300,
+      };
+    });
+    font.setFuncs(fontFuncs);
+    expect(font.vExtents()).to.deep.equal({
+      ascender: 100,
+      descender: 200,
+      lineGap: 300,
+    });
+  });
+});
+
 describe('Buffer', function () {
   it('setDirection controls direction of glyphs', function () {
     blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));