harfbuzzjs 0.2.1 → 0.3.1

package/hbjs.js

@@ -9,6 +9,7 @@ function hbjs(instance) {
   var utf8Decoder = new TextDecoder("utf8");
 
   var HB_MEMORY_MODE_WRITABLE = 2;
+  var HB_SET_VALUE_INVALID = -1;
 
   function hb_tag(s) {
     return (
@@ -54,6 +55,42 @@ function hbjs(instance) {
     };
   }
 
+  /**
+   * Return the typed array of HarfBuzz set contents.
+   * @template {typeof Uint8Array | typeof Uint32Array | typeof Int32Array | typeof Float32Array} T
+   * @param {number} setPtr Pointer of set
+   * @param {T} arrayClass Typed array class
+   * @returns {InstanceType<T>} Typed array instance
+   */
+  function typedArrayFromSet(setPtr, arrayClass) {
+    let heap = heapu8;
+    if (arrayClass === Uint32Array) {
+      heap = heapu32;
+    } else if (arrayClass === Int32Array) {
+      heap = heapi32;
+    } else if (arrayClass === Float32Array) {
+      heap = heapf32;
+    }
+    const bytesPerElment = arrayClass.BYTES_PER_ELEMENT;
+    const setCount = exports.hb_set_get_population(setPtr);
+    const arrayPtr = exports.malloc(
+      setCount * bytesPerElment,
+    );
+    const arrayOffset = arrayPtr / bytesPerElment;
+    const array = heap.subarray(
+      arrayOffset,
+      arrayOffset + setCount,
+    );
+    heap.set(array, arrayOffset);
+    exports.hb_set_next_many(
+      setPtr,
+      HB_SET_VALUE_INVALID,
+      arrayPtr,
+      setCount,
+    );
+    return array;
+  }
+
   /**
   * Create an object representing a Harfbuzz face.
   * @param {object} blob An object returned from `createBlob`.
@@ -98,6 +135,16 @@ function hbjs(instance) {
         exports.free(axis);
         return result;
       },
+      /**
+       * Return unicodes the face supports
+       */
+      collectUnicodes: function() {
+        var unicodeSetPtr = exports.hb_set_create();
+        exports.hb_face_collect_unicodes(ptr, unicodeSetPtr);
+        var result = typedArrayFromSet(unicodeSetPtr, Uint32Array);
+        exports.hb_set_destroy(ptr);
+        return result;
+      },
       /**
        * Free the object.
        */
@@ -110,6 +157,9 @@ function hbjs(instance) {
   var pathBufferSize = 65536; // should be enough for most glyphs
   var pathBuffer = exports.malloc(pathBufferSize); // permanently allocated
 
+  var nameBufferSize = 256; // should be enough for most glyphs
+  var nameBuffer = exports.malloc(nameBufferSize); // permanently allocated
+
   /**
   * Create an object representing a Harfbuzz font.
   * @param {object} blob An object returned from `createFace`.
@@ -126,8 +176,24 @@ function hbjs(instance) {
       return svgLength > 0 ? utf8Decoder.decode(heapu8.subarray(pathBuffer, pathBuffer + svgLength)) : "";
     }
 
+    /**
+     * Return glyph name.
+     * @param {number} glyphId ID of the requested glyph in the font.
+     **/
+    function glyphName(glyphId) {
+      exports.hb_font_glyph_to_string(
+        ptr,
+        glyphId,
+        nameBuffer,
+        nameBufferSize
+      );
+      var array = heapu8.subarray(nameBuffer, nameBuffer + nameBufferSize);
+      return utf8Decoder.decode(array.slice(0, array.indexOf(0)));
+    }
+
     return {
       ptr: ptr,
+      glyphName: glyphName,
       glyphToPath: glyphToPath,
       /**
       * Return a glyph as a JSON path string
@@ -287,12 +353,14 @@ function hbjs(instance) {
       *   - ax: Advance width (width to advance after this glyph is painted)
       *   - ay: Advance height (height to advance after this glyph is painted)
       *   - dx: X displacement (adjustment in X dimension when painting this glyph)
-      *   - d5: Y displacement (adjustment in Y dimension when painting this glyph)
+      *   - dy: Y displacement (adjustment in Y dimension when painting this glyph)
+      *   - flags: Glyph flags like `HB_GLYPH_FLAG_UNSAFE_TO_BREAK` (0x1)
       **/
-      json: function (font) {
+      json: function () {
         var length = exports.hb_buffer_get_length(ptr);
         var result = [];
-        var infosPtr32 = exports.hb_buffer_get_glyph_infos(ptr, 0) / 4;
+        var infosPtr = exports.hb_buffer_get_glyph_infos(ptr, 0);
+        var infosPtr32 = infosPtr / 4;
         var positionsPtr32 = exports.hb_buffer_get_glyph_positions(ptr, 0) / 4;
         var infos = heapu32.subarray(infosPtr32, infosPtr32 + 5 * length);
         var positions = heapi32.subarray(positionsPtr32, positionsPtr32 + 5 * length);
@@ -303,7 +371,8 @@ function hbjs(instance) {
             ax: positions[i * 5 + 0],
             ay: positions[i * 5 + 1],
             dx: positions[i * 5 + 2],
-            dy: positions[i * 5 + 3]
+            dy: positions[i * 5 + 3],
+            flags: exports.hb_glyph_info_get_glyph_flags(infosPtr + i * 20)
           });
         }
         return result;

package/hbjs.symbols

@@ -0,0 +1,41 @@
+_hb_blob_create
+_hb_blob_destroy
+_hb_blob_get_data
+_hb_blob_get_length
+_hb_buffer_add_utf16
+_hb_buffer_add_utf8
+_hb_buffer_create
+_hb_buffer_destroy
+_hb_buffer_get_glyph_infos
+_hb_buffer_get_glyph_positions
+_hb_buffer_get_length
+_hb_buffer_guess_segment_properties
+_hb_buffer_set_cluster_level
+_hb_buffer_set_direction
+_hb_buffer_set_flags
+_hb_buffer_set_language
+_hb_buffer_set_script
+_hb_face_create
+_hb_face_collect_unicodes
+_hb_face_destroy
+_hb_face_get_upem
+_hb_face_reference_table
+_hb_font_create
+_hb_font_destroy
+_hb_font_glyph_to_string
+_hb_font_set_scale
+_hb_font_set_variations
+_hb_glyph_info_get_glyph_flags
+_hb_language_from_string
+_hb_ot_var_get_axis_infos
+_hb_script_from_string
+_hb_set_create
+_hb_set_destroy
+_hb_set_get_population
+_hb_set_next_many
+_hb_shape
+_hbjs_glyph_svg
+_hbjs_shape_with_trace
+_malloc
+_free
+_free_ptr

package/index.js

@@ -6,7 +6,6 @@ module.exports = new Promise(function (resolve, reject) {
   fs.readFile(path.resolve(__dirname, 'hb.wasm'), function (err, data) {
     if (err) { reject(err); return; }
     WebAssembly.instantiate(data).then(function (result) {
-      result.instance.exports.memory.grow(400); // each page is 64kb in size
       resolve(hbjs(result.instance));
     }, reject);
   });

package/package.json

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

package/hbjs.c

@@ -1,284 +0,0 @@
-#include "harfbuzz/src/hb.h"
-#include "harfbuzz/src/hb-ot.h"
-#include "string.h"
-
-enum {
-  HB_SHAPE_DONT_STOP,
-  HB_SHAPE_GSUB_PHASE,
-  HB_SHAPE_GPOS_PHASE
-};
-
-typedef struct user_data_t {
-  char *str;
-  unsigned size;
-  unsigned consumed;
-  hb_bool_t failure;
-  unsigned int stop_at;
-  unsigned int stop_phase;
-  hb_bool_t stopping;
-  unsigned int current_phase;
-} user_data_t;
-
-
-/* Our modified iota, why not using libc's? it is going to be used
-   in harfbuzzjs where libc isn't available */
-static void _hb_reverse (char *buf, unsigned int len)
-{
-  unsigned start = 0, end = len - 1;
-  while (start < end)
-  {
-    char c = buf[end];
-    buf[end] = buf[start];
-    buf[start] = c;
-    start++; end--;
-  }
-}
-static unsigned _hb_itoa (int32_t num, char *buf)
-{
-  unsigned int i = 0;
-  hb_bool_t is_negative = num < 0;
-  if (is_negative) num = -num;
-  do
-  {
-    buf[i++] = '0' + num % 10;
-    num /= 10;
-  } while (num);
-  if (is_negative) buf[i++] = '-';
-  _hb_reverse (buf, i);
-  buf[i] = '\0';
-  return i;
-}
-
-static void _append(user_data_t *user_data, char x) {
-  if (user_data->consumed >= user_data->size) {
-    user_data->failure = 1;
-    return;
-  }
-  user_data->str[user_data->consumed++] = x;
-}
-
-static void _strcat(user_data_t *user_data, const char *s) {
-  while (*s) {
-    _append(user_data, *s++);
-  }
-}
-
-#define ITOA_BUF_SIZE 12 // 10 digits in int32, 1 for negative sign, 1 for \0
-
-static void
-move_to (hb_position_t to_x, hb_position_t to_y, user_data_t *user_data)
-{
-  /* 4 = command character space + comma + array starts with 0 index + nul character space */
-  if (user_data->consumed + 2 * ITOA_BUF_SIZE + 4 > user_data->size) return;
-  _append(user_data, 'M');
-  user_data->consumed += _hb_itoa (to_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (to_y, user_data->str + user_data->consumed);
-}
-
-static void
-line_to (hb_position_t to_x, hb_position_t to_y, user_data_t *user_data)
-{
-  if (user_data->consumed + 2 * ITOA_BUF_SIZE + 4 > user_data->size) return;
-  _append(user_data, 'L');
-  user_data->consumed += _hb_itoa (to_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (to_y, user_data->str + user_data->consumed);
-}
-
-static void
-quadratic_to (hb_position_t control_x, hb_position_t control_y,
-	  hb_position_t to_x, hb_position_t to_y,
-	  user_data_t *user_data)
-{
-
-  if (user_data->consumed + 4 * ITOA_BUF_SIZE + 6 > user_data->size) return;
-  _append(user_data, 'Q');
-  user_data->consumed += _hb_itoa (control_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (control_y, user_data->str + user_data->consumed);
-  _append(user_data, ' ');
-  user_data->consumed += _hb_itoa (to_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (to_y, user_data->str + user_data->consumed);
-}
-
-static void
-cubic_to (hb_position_t control1_x, hb_position_t control1_y,
-	  hb_position_t control2_x, hb_position_t control2_y,
-	  hb_position_t to_x, hb_position_t to_y,
-	  user_data_t *user_data)
-{
-  if (user_data->consumed + 6 * ITOA_BUF_SIZE + 8 > user_data->size) return;
-  _append(user_data, 'C');
-  user_data->consumed += _hb_itoa (control1_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (control1_y, user_data->str + user_data->consumed);
-  _append(user_data, ' ');
-  user_data->consumed += _hb_itoa (control2_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (control2_y, user_data->str + user_data->consumed);
-  _append(user_data, ' ');
-  user_data->consumed += _hb_itoa (to_x, user_data->str + user_data->consumed);
-  _append(user_data, ',');
-  user_data->consumed += _hb_itoa (to_y, user_data->str + user_data->consumed);
-}
-
-static void
-close_path (user_data_t *user_data)
-{
-  _append(user_data, 'Z');
-}
-
-static hb_draw_funcs_t *funcs = 0;
-
-int
-hbjs_glyph_svg (hb_font_t *font, hb_codepoint_t glyph, char *buf, unsigned buf_size)
-{
-  if (funcs == 0) /* not the best pattern for multi-threaded apps which is not a concern here */
-  {
-    funcs = hb_draw_funcs_create (); /* will be leaked */
-    hb_draw_funcs_set_move_to_func (funcs, (hb_draw_move_to_func_t) move_to);
-    hb_draw_funcs_set_line_to_func (funcs, (hb_draw_line_to_func_t) line_to);
-    hb_draw_funcs_set_quadratic_to_func (funcs, (hb_draw_quadratic_to_func_t) quadratic_to);
-    hb_draw_funcs_set_cubic_to_func (funcs, (hb_draw_cubic_to_func_t) cubic_to);
-    hb_draw_funcs_set_close_path_func (funcs, (hb_draw_close_path_func_t) close_path);
-  }
-
-  user_data_t user_data = {
-    .str = buf,
-    .size = buf_size,
-    .consumed = 0,
-    .failure = 0,
-    /* Following members not relevant for SVG */
-    .stop_at = 0,
-    .stop_phase = 0,
-    .stopping = 0,
-    .current_phase = 0
-  };
-  hb_font_draw_glyph (font, glyph, funcs, &user_data);
-  if (user_data.failure) { return -1; }
-  buf[user_data.consumed] = '\0';
-  return user_data.consumed;
-}
-
-static hb_bool_t do_trace (hb_buffer_t *buffer,
-                           hb_font_t   *font,
-                           const char  *message,
-                           user_data_t *user_data) {
-  unsigned int consumed;
-  unsigned int num_glyphs = hb_buffer_get_length (buffer);
-
-  if (strcmp(message, "start table GSUB") == 0) {
-    user_data->current_phase = HB_SHAPE_GSUB_PHASE;
-  } else if (strcmp(message, "start table GPOS") == 0) {
-    user_data->current_phase = HB_SHAPE_GPOS_PHASE;
-  }
-
-
-  if (user_data->current_phase != user_data->stop_phase) {
-    user_data->stopping = 0;
-  }
-
-  // If we overflowed, keep going anyway.
-  if (user_data->failure) return 1;
-
-  if (user_data->stop_phase != HB_SHAPE_DONT_STOP) {
-    // Do we need to start stopping?
-    char itoabuf[ITOA_BUF_SIZE];
-    _hb_itoa(user_data->stop_at, itoabuf);
-    if ((user_data->current_phase == user_data->stop_phase) &&
-        (strncmp(message, "end lookup ", 11) == 0) &&
-        (strcmp(message + 11, itoabuf) == 0)) {
-      user_data->stopping = 1;
-    }
-  }
-
-  // If we need to stop, stop.
-  if (user_data->stopping) return 0;
-
-  _strcat(user_data, "{\"m\":\"");
-  _strcat(user_data, message);
-  _strcat(user_data, "\",\"t\":");
-  hb_buffer_serialize_glyphs(buffer, 0, num_glyphs,
-    user_data->str + user_data->consumed,
-    user_data->size - user_data->consumed,
-    &consumed,
-    font,
-    HB_BUFFER_SERIALIZE_FORMAT_JSON,
-    HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES);
-  user_data->consumed += consumed;
-  _strcat(user_data, "},\n");
-
-
-  return 1;
-}
-
-unsigned
-hbjs_shape_with_trace (hb_font_t *font, hb_buffer_t* buf,
-                       char* featurestring,
-                       int stop_at, int stop_phase,
-                       char *outbuf, unsigned buf_size) {
-  user_data_t user_data = {
-    .str = outbuf,
-    .size = buf_size,
-    .consumed = 0,
-    .failure = 0,
-    .stop_at = stop_at,
-    .stop_phase = stop_phase,
-    .stopping = 0,
-    .current_phase = 0
-  };
-
-  int num_features = 0;
-  hb_feature_t* features = NULL;
-
-  if (*featurestring) {
-    /* count the features first, so we can allocate memory */
-    char* p = featurestring;
-    do {
-      num_features++;
-      p = strchr (p, ',');
-      if (p)
-        p++;
-    } while (p);
-
-    features = (hb_feature_t *) calloc (num_features, sizeof (*features));
-
-    /* now do the actual parsing */
-    p = featurestring;
-    num_features = 0;
-    while (p && *p) {
-      char *end = strchr (p, ',');
-      if (hb_feature_from_string (p, end ? end - p : -1, &features[num_features]))
-        num_features++;
-      p = end ? end + 1 : NULL;
-    }
-  }
-
-  hb_buffer_set_message_func (buf, (hb_buffer_message_func_t)do_trace, &user_data, NULL);
-  user_data.str[user_data.consumed++] = '[';
-  hb_shape(font, buf, features, num_features);
-
-  if (user_data.failure) return -1;
-
-  user_data.str[user_data.consumed-2] = ']';
-  user_data.str[user_data.consumed-1] = '\0';
-  return user_data.consumed;
-}
-
-#ifdef MAIN
-#include <stdio.h>
-int main() {
-    hb_blob_t *blob = hb_blob_create_from_file ("/home/ebrahim/Desktop/harfbuzzjs/harfbuzz/test/subset/data/fonts/Roboto-Regular.ttf");
-    hb_face_t *face = hb_face_create (blob, 0);
-    hb_blob_destroy (blob);
-    hb_font_t *font = hb_font_create (face);
-    hb_face_destroy (face);
-    char buf[1024];
-    buf[0] = '\0';
-    printf ("%d %d\n", hb_blob_get_length (blob), hbjs_ot_glyph_svg (font, 0, buf, sizeof (buf)));
-    puts (buf);
-    hb_font_destroy (font);
-}
-#endif

package/libc/ctype.h

@@ -1,73 +0,0 @@
-// Source: https://github.com/intel/zephyr/blob/c187536/lib/libc/minimal/include/ctype.h
-/* ctype.h */
-
-/*
- * Copyright (c) 2015 Intel Corporation.
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#ifndef __INC_ctype_h__
-#define __INC_ctype_h__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-static inline int isupper(int a)
-{
-	return ((unsigned)(a)-'A') < 26;
-}
-
-static inline int isalpha(int c)
-{
-	return (((unsigned)c|32)-'a') < 26;
-}
-
-static inline int isspace(int c)
-{
-	return c == ' ' || ((unsigned)c-'\t') < 5;
-}
-
-static inline int isgraph(int c)
-{
-	return ((((unsigned)c) > ' ') && (((unsigned)c) <= '~'));
-}
-
-static inline int isprint(int c)
-{
-	return ((((unsigned)c) >= ' ') && (((unsigned)c) <= '~'));
-}
-
-static inline int isdigit(int a)
-{
-	return (((unsigned)(a)-'0') < 10);
-}
-
-static inline int isxdigit(int a)
-{
-	unsigned int ua = (unsigned int)a;
-
-	return ((ua - '0') < 10) || ((ua - 'a') < 6) || ((ua - 'A') < 6);
-}
-
-static inline int tolower(int chr)
-{
-	return (chr >= 'A' && chr <= 'Z') ? (chr + 32) : (chr);
-}
-
-static inline int toupper(int chr)
-{
-	return (chr >= 'a' && chr <= 'z') ? (chr - 32) : (chr);
-}
-
-static inline int isalnum(int chr)
-{
-	return isalpha(chr) || isdigit(chr);
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  /* __INC_ctype_h__ */