Modernize package to Node-API, ES, add TypeScript bindings

README.md

@@ -18,38 +18,52 @@ or
 ## Usage
 
 ```javascript
-var mmh3 = require('murmurhash3');
-    
-mmh3.murmur32('key', function(err, hashValue){
+import { murmur32, murmur128Hex } from 'murmurhash3';
+
+murmur32('key', (err, hashValue) => {
   if (err) throw err;
-  ...
+  // ...
 });
-mmh3.murmur128Hex('key', function(err, hashValue){
+
+murmur128Hex('key', (err, hashValue) => {
   if (err) throw err;
-  ...
+  // ...
 });
 ```
 
+You can also wrap the async functions with `util.promisify` for `async`/`await`:
+
+```javascript
+import { promisify } from 'node:util';
+import { murmur32, murmur128Hex } from 'murmurhash3';
+
+const murmur32Async = promisify(murmur32);
+const murmur128HexAsync = promisify(murmur128Hex);
+
+const hash32 = await murmur32Async('key');
+const hash128 = await murmur128HexAsync('key');
+```
+
 ## Functions
 
 ### Async interfaces
 
-    murmur32(key [,seed], callback);    // return 32bit integer value
-    murmur32Hex(key [,seed], callback); // return 32bit hexadecimal string
-    murmur128(key [,seed], callback);   // return array that have 4 elements of 32bit integer
-    murmur128Hex(key [,seed], callback);// return 128bit hexadecimal string
+    murmur32(key [, seed], callback);     // returns 32bit integer value
+    murmur32Hex(key [, seed], callback);  // returns 32bit hexadecimal string
+    murmur128(key [, seed], callback);    // returns array of 4 32bit integers
+    murmur128Hex(key [, seed], callback); // returns 128bit hexadecimal string
 
-- `seed` is optional argument. (unsigned integer)
-- The callback gets two arguments `(error, hashValue)`. 
+- `seed` is an optional argument. (unsigned integer)
+- The callback receives two arguments `(error, hashValue)`.
 
 ### Sync interfaces
 
-    murmur32Sync(key [,seed]);    // return 32bit integer value
-    murmur32HexSync(key, [,seed]); // return 32bit hexadecimal string
-    murmur128Sync(key [,seed]);   // return array that have 4 elements of 32bit integer
-    murmur128HexSync(key [,seed]);// return 128bit hexadecimal string
+    murmur32Sync(key [, seed]);    // returns 32bit integer value
+    murmur32HexSync(key [, seed]); // returns 32bit hexadecimal string
+    murmur128Sync(key [, seed]);   // returns array of 4 32bit integers
+    murmur128HexSync(key [, seed]);// returns 128bit hexadecimal string
 
-- `seed` is optional argument. (unsigned integer)
+- `seed` is an optional argument. (unsigned integer)
 
 ## Requirement
 

binding.gyp

@@ -8,8 +8,9 @@
       'cflags!': ['-fno-exceptions'],
       'cflags_cc!': ['-fno-exception'],
       "include_dirs" : [
-          "<!(node -e \"require('nan')\")"
+          "<!@(node -p \"require('node-addon-api').include\")"
       ],
+      'defines': [ 'NAPI_CPP_EXCEPTIONS' ],
       'conditions': [
         ['OS=="win"', {
             'msvs_settings': {

lib/murmurhash3.d.ts

@@ -0,0 +1,34 @@
+declare module 'murmurhash3' {
+  /** Library version. */
+  export const version: string;
+
+  type Murmur32Callback = (err: Error | null, hash: number) => void;
+  type Murmur32HexCallback = (err: Error | null, hash: string) => void;
+  type Murmur128Callback = (err: Error | null, hash: number[]) => void;
+  type Murmur128HexCallback = (err: Error | null, hash: string) => void;
+
+  /** return 32bit integer value */
+  export function murmur32(key: string, seed: number, callback: Murmur32Callback): void;
+  export function murmur32(key: string, callback: Murmur32Callback): void;
+
+  /** return 32bit hexadecimal string */
+  export function murmur32Hex(key: string, seed: number, callback: Murmur32HexCallback): void;
+  export function murmur32Hex(key: string, callback: Murmur32HexCallback): void;
+
+  /** return array that have 4 elements of 32bit integer */
+  export function murmur128(key: string, seed: number, callback: Murmur128Callback): void;
+  export function murmur128(key: string, callback: Murmur128Callback): void;
+
+  /** return 128bit hexadecimal string */
+  export function murmur128Hex(key: string, seed: number, callback: Murmur128HexCallback): void;
+  export function murmur128Hex(key: string, callback: Murmur128HexCallback): void;
+
+  /** return 32bit integer value */
+  export function murmur32Sync(key: string, seed?: number): number;
+  /** return 32bit hexadecimal string */
+  export function murmur32HexSync(key: string, seed?: number): string;
+  /** return array that have 4 elements of 32bit integer */
+  export function murmur128Sync(key: string, seed?: number): number[];
+  /** return 128bit hexadecimal string */
+  export function murmur128HexSync(key: string, seed?: number): string;
+}

lib/murmurhash3.js

@@ -4,39 +4,41 @@
 * MIT Licensed
 */
 
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
 /**
  * Library version.
  */
+export const version = '0.6.0';
 
-exports.version = '0.5.0';
-
-var binding;
+let binding;
 try {
-  binding = require(__dirname + '/../build/Release/murmurhash3');
+  binding = require('../build/Release/murmurhash3');
 } catch(e) {
-  binding = require(__dirname + '/../build/default/murmurhash3');
+  binding = require('../build/default/murmurhash3');
 }
 
-var E_CALLBACK_MISSING = "Callback function is missing";
+const E_CALLBACK_MISSING = "Callback function is missing";
 
-//Aync interface
+//Async interface
 
-exports.murmur32 = function(key, seed, cb) {
+export function murmur32(key, seed, cb) {
   if ( typeof seed == 'function') {
     cb = seed;
     seed = 0;
   }
   if (cb === undefined || typeof cb != 'function') {
     throw new Error(E_CALLBACK_MISSING);
   }
-  var res = binding.murmur32(key, seed, false, function(err, res) {
+  const res = binding.murmur32(key, seed, false, function(err, res) {
     // Cast signed integer to unsigned integer
     cb(err, res >>> 0);
   });
   return res;
-};
+}
 
-exports.murmur32Hex = function(key, seed, cb) {
+export function murmur32Hex(key, seed, cb) {
   if ( typeof seed == 'function') {
     cb = seed;
     seed = 0;
@@ -45,9 +47,9 @@ exports.murmur32Hex = function(key, seed, cb) {
     throw new Error(E_CALLBACK_MISSING);
   }
   return binding.murmur32(key, seed, true, cb);
-};
+}
 
-exports.murmur128 = function(key, seed, cb) {
+export function murmur128(key, seed, cb) {
   if ( typeof seed == 'function') {
     cb = seed;
     seed = 0;
@@ -56,15 +58,15 @@ exports.murmur128 = function(key, seed, cb) {
     throw new Error(E_CALLBACK_MISSING);
   }
   binding.murmur128(key, seed, false, function(err, res) {
-    for (var i = 0; i < res.length; i++) {
+    for (let i = 0; i < res.length; i++) {
       // Cast signed integer to unsigned integer
       res[i] = res[i] >>> 0;
     }
     cb(err, res);
   });
-};
+}
 
-exports.murmur128Hex = function(key, seed, cb) {
+export function murmur128Hex(key, seed, cb) {
   if ( typeof seed == 'function') {
     cb = seed;
     seed = 0;
@@ -73,42 +75,42 @@ exports.murmur128Hex = function(key, seed, cb) {
     throw new Error(E_CALLBACK_MISSING);
   }
   return binding.murmur128(key, seed, true, cb);
-};
+}
 
 
 //Sync interface
 
-exports.murmur32Sync = function(key, seed) {
+export function murmur32Sync(key, seed) {
   // Cast signed integer to unsigned integer
   if (seed === undefined) {
     seed = 0;
   }
-  var res = binding.murmur32Sync(key, seed, false) >>> 0;
+  const res = binding.murmur32Sync(key, seed, false) >>> 0;
   return res;
-};
+}
 
-exports.murmur32HexSync = function(key, seed) {
+export function murmur32HexSync(key, seed) {
   if (seed === undefined) {
     seed = 0;
   }
   return binding.murmur32Sync(key, seed, true);
-};
+}
 
-exports.murmur128Sync = function(key, seed) {
+export function murmur128Sync(key, seed) {
   if (seed === undefined) {
     seed = 0;
   }
-  var res = binding.murmur128Sync(key, seed, false);
-  for (var i = 0; i < res.length; i++) {
+  const res = binding.murmur128Sync(key, seed, false);
+  for (let i = 0; i < res.length; i++) {
     // Cast signed integer to unsigned integer
     res[i] = res[i] >>> 0;
   }
   return res;
-};
+}
 
-exports.murmur128HexSync = function(key, seed) {
+export function murmur128HexSync(key, seed) {
   if (seed === undefined) {
     seed = 0;
   }
   return binding.murmur128Sync(key, seed, true);
-};
+}