harfbuzzjs 0.6.0 → 0.8.0

package/package.json

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

package/test/index.js

@@ -569,6 +569,195 @@ describe('Buffer', function () {
     const glyphs = buffer.json();
     expect(glyphs[0].g).not.to.equal(3 /* space */);
   });
+
+  it('setFlags ignores invalid flags', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('abc');
+    buffer.setFlags(['invalidFlag']);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.json();
+    expect(glyphs[0].g).to.equal(68 /* a */);
+  });
+
+  it('setFlags with PRODUCE_SAFE_TO_INSERT_TATWEEL affects glyph flags', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSansArabic-Variable.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('بلا');
+    buffer.setFlags(['PRODUCE_SAFE_TO_INSERT_TATWEEL']);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const flags = Array.from(buffer.json().map(g => g.flags));
+    expect(flags).to.deep.equal([5, 0]);
+
+    buffer.clearContents();
+    buffer.addText('بلا');
+    buffer.setFlags([]);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const flags2 = Array.from(buffer.json().map(g => g.flags));
+    expect(flags2).to.deep.equal([1, 0]);
+  });
+
+  it('serialize ignores invalid flags', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('abc');
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    const glyphs = buffer.serialize(font, 0, null, "TEXT", ["invalidFlag"]);
+    expect(glyphs).to.deep.equal("[a=0+561|b=1+615|c=2+480]");
+  });
+
+  it('reset resets the buffer', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('abc');
+    buffer.guessSegmentProperties();
+    expect(buffer.getContentType()).to.equal("UNICODE");
+    hb.shape(font, buffer)
+    expect(buffer.getContentType()).to.equal("GLYPHS");
+    buffer.reset();
+    expect(buffer.getContentType()).to.equal("INVALID");
+  });
+
+  it('getLength gets the length before and after shaping', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('fi');
+    expect(buffer.getLength()).to.equal(2);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer)
+    expect(buffer.getLength()).to.equal(1);
+  });
+
+  it('getInfos and getPositions return empty arrays for empty buffer', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    expect(buffer.getGlyphInfos()).to.deep.equal([]);
+    expect(buffer.getGlyphPositions()).to.deep.equal([]);
+  });
+
+  it('getInfos and getPositions return non empty arrays for non empty buffer', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('x\u0300fi'); // combining mark and ligature to make the test more interesting
+    buffer.guessSegmentProperties();
+
+    // before shaping
+    expect(buffer.getGlyphInfos()).to.deep.equal([
+      { codepoint: 120, cluster: 0 },
+      { codepoint: 768, cluster: 1 },
+      { codepoint: 102, cluster: 2 },
+      { codepoint: 105, cluster: 3 }
+    ]);
+    expect(buffer.getGlyphPositions()).to.deep.equal([
+      { x_advance: 0, y_advance: 0, x_offset: 0, y_offset: 0 },
+      { x_advance: 0, y_advance: 0, x_offset: 0, y_offset: 0 },
+      { x_advance: 0, y_advance: 0, x_offset: 0, y_offset: 0 },
+      { x_advance: 0, y_advance: 0, x_offset: 0, y_offset: 0 }
+    ]);
+
+    hb.shape(font, buffer);
+    // after shaping
+    expect(buffer.getGlyphInfos()).to.deep.equal([
+      { codepoint: 91, cluster: 0 },
+      { codepoint: 2662, cluster: 0 },
+      { codepoint: 1652, cluster: 2 }
+    ]);
+    expect(buffer.getGlyphPositions()).to.deep.equal([
+      { x_advance: 529, y_advance: 0, x_offset: 0, y_offset: 0 },
+      { x_advance: 0, y_advance: 0, x_offset: 97, y_offset: 0 },
+      { x_advance: 602, y_advance: 0, x_offset: 0, y_offset: 0 }
+    ]);
+  });
+
+  it('getPositions returns empty array for buffer without positions', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+    buffer.addText('abc');
+    buffer.guessSegmentProperties();
+    var currentPhase = "";
+    buffer.setMessageFunc((buffer, font, message) => {
+      if (message.startsWith("start table GSUB"))
+        currentPhase = "GSUB";
+      else if (message.startsWith("start table GPOS"))
+        currentPhase = "GPOS";
+
+      if (currentPhase === "GSUB")
+        expect(buffer.getGlyphPositions()).to.deep.equal([]);
+      else if (currentPhase === "GPOS")
+        expect(buffer.getGlyphPositions()).to.not.deep.equal([]);
+
+      return true;
+    });
+    hb.shape(font, buffer);
+  });
+
+  it('updateGlyphPositions updates the glyph positions', function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    buffer = hb.createBuffer();
+
+    // text with a base glyph and two marks to test mkmk after manually updating glyph positions
+    var text = 'x\u0302\u0300';
+
+    // without updateGlyphPositions
+    buffer.addText(text);
+    buffer.guessSegmentProperties();
+    hb.shape(font, buffer);
+    var positions = buffer.getGlyphPositions();
+    expect(positions[1].y_offset).to.equal(0);
+    expect(positions[2].y_offset).to.equal(229);
+
+    // with updateGlyphPositions inside buffer message callback
+    buffer.clearContents();
+    buffer.addText(text);
+    buffer.guessSegmentProperties();
+    var currentPhase = "";
+    buffer.setMessageFunc((buffer, font, message) => {
+      if (message.startsWith("start table GSUB"))
+        currentPhase = "GSUB";
+      else if (message.startsWith("start table GPOS"))
+        currentPhase = "GPOS";
+
+      // modify the 2nd glyph y_offset after the last mark lookup and before mkmk lookups
+      if (currentPhase === "GPOS" && message.startsWith("end lookup 4 feature 'mark'")) {
+        var positions = buffer.getGlyphPositions();
+        expect(positions[1].y_offset).to.equal(0);
+        expect(positions[2].y_offset).to.equal(0);
+        positions[1].y_offset += 10;
+        buffer.updateGlyphPositions(positions);
+      }
+
+      return true;
+    });
+
+    hb.shape(font, buffer);
+    var positions = buffer.getGlyphPositions();
+
+    // both mark glyphs now be offset vertically by 10, since the second mark attaches to the first mark
+    expect(positions[1].y_offset).to.equal(10);
+    expect(positions[2].y_offset).to.equal(239);
+  });
 });
 
 describe('shape', function () {
@@ -714,9 +903,8 @@ describe('shape', function () {
     var glyphs = buffer.json();
     expect(glyphs).to.have.lengthOf(2);
     expect(glyphs[0].g).to.equal(118);
-    buffer.destroy();
 
-    buffer = hb.createBuffer();
+    buffer.clearContents();
     buffer.addText('५ल');
     buffer.setLanguage('dty');
     buffer.guessSegmentProperties();
@@ -737,9 +925,8 @@ describe('shape', function () {
     var glyphs = buffer.json();
     expect(glyphs).to.have.lengthOf(2);
     expect(glyphs[0].g).to.equal(118);
-    buffer.destroy();
 
-    buffer = hb.createBuffer();
+    buffer.clearContents();
     buffer.addText('५ल');
     buffer.setLanguage('x-hbot-4e455020'); // 'NEP '
     buffer.guessSegmentProperties();
@@ -758,8 +945,51 @@ describe('misc', function () {
     expect(version).to.have.property('micro').that.is.a('number');
     expect(version.major).to.be.at.least(10);
   });
+
   it('get version string', function () {
     const version_string = hb.version_string();
     expect(version_string).to.match(/^\d+\.\d+\.\d+$/);
   });
+
+  it('convert OpenType tag to script', function () {
+    expect(hb.otTagToScript('arab')).to.equal('Arab');
+    expect(hb.otTagToScript('latn')).to.equal('Latn');
+    expect(hb.otTagToScript('dev2')).to.equal('Deva');
+    expect(hb.otTagToScript('nko ')).to.equal('Nkoo');
+    expect(hb.otTagToScript('DFLT')).to.equal('\0\0\0\0');
+  });
+
+  it('convert OpenType tag to language', function () {
+    expect(hb.otTagToLanguage('ARA ')).to.equal('ar');
+    expect(hb.otTagToLanguage('ENG ')).to.equal('en');
+    expect(hb.otTagToLanguage('BAD0')).to.equal('bad');
+    expect(hb.otTagToLanguage('SYRE')).to.equal('und-syre');
+  });
+
+  it("test that calling functions repeatedly doesn't exhaust memory", function () {
+    blob = hb.createBlob(fs.readFileSync(path.join(__dirname, 'fonts/noto/NotoSans-Regular.ttf')));
+    face = hb.createFace(blob);
+    font = hb.createFont(face);
+    for (let i = 0; i < 10000; i++) {
+      expect(face.listNames()).to.not.be.null;
+      expect(face.getName(0, "en")).to.not.be.null;
+      expect(font.hExtents()).to.not.be.null;
+      expect(font.vExtents()).to.not.be.null;
+      expect(font.glyphHOrigin(0)).to.not.be.null;
+      expect(font.glyphVOrigin(0)).to.be.null;
+      expect(font.glyphExtents(0)).to.not.be.null;
+      expect(font.glyphFromName("a")).to.not.be.null;
+      for (let tableTag of ["GSUB", "GPOS"]) {
+        expect(face.getTableFeatureTags(tableTag)).to.not.be.null;
+        expect(face.getTableScriptTags(tableTag)).to.not.be.null;
+        expect(face.getScriptLanguageTags(tableTag, 0)).to.not.be.null;
+        expect(face.getLanguageFeatureTags(tableTag, 0, 0)).to.not.be.null;
+        if (tableTag === "GSUB") {
+          expect(face.getFeatureNameIds(tableTag, 50)).to.not.be.null;
+        } else {
+          expect(face.getFeatureNameIds(tableTag, 50)).to.be.null;
+        }
+      }
+    }
+  });
 });

package/.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-	"makefile.configureOnOpen": true
-}