node-liblzma 1.0.4-8 → 1.1.4

package/package.json

@@ -1,13 +1,31 @@
 {
   "name": "node-liblzma",
-  "version": "1.0.4-8",
-  "description": "Liblzma bindings for NodeJS (aka xzlib)",
+  "version": "1.1.4",
+  "description": "NodeJS wrapper for liblzma",
   "main": "./lib/lzma.js",
   "scripts": {
-    "test": "./node_modules/.bin/ubs test",
-    "install": "./node_modules/.bin/ubs install",
-    "preinstall": "npm install node-pre-gyp",
-    "prepublish": "./node_modules/.bin/ubs build_coffee"
+    "install": "node-gyp install",
+    "postinstall": "run-p build:*",
+    "build:native": "node-gyp rebuild",
+    "build:coffee": "coffee --compile --output lib/ src/",
+    "rebuild": "node-gyp rebuild",
+    "test": "npx mocha test/*.coffee"
+  },
+  "dependencies": {
+    "node-addon-api": "4.2.0",
+    "node-gyp-build": "4.3.0",
+    "npm-run-all": "4.1.5"
+  },
+  "devDependencies": {
+    "coffeescript": "2.6.1",
+    "expect.js": "0.3.1",
+    "mocha": "9.2.1",
+    "node-gyp": "8.4.1",
+    "tsd": "0.19.1"
+  },
+  "types": "index.d.ts",
+  "engines": {
+    "node": ">12.0.0"
   },
   "repository": {
     "type": "git",
@@ -33,24 +51,20 @@
     "url": "https://github.com/oorabona/node-liblzma/issues"
   },
   "homepage": "https://github.com/oorabona/node-liblzma",
-  "dependencies": {
-    "nan": "latest",
-    "node-pre-gyp": "latest",
-    "ubs": "latest"
-  },
-  "devDependencies": {
-    "coffee-script": "*",
-    "expect.js": "^0.3.1",
-    "mocha": "^2.0.1",
-    "q": "^1.0.1"
+  "binary": {
+    "module_name": "liblzma"
   },
-  "engines": {
-    "node": ">=0.10.1"
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
   },
-  "binary": {
-    "module_name": "node-liblzma",
-    "module_path": "./build/",
-    "host": "https://github.com/",
-    "remote_path": "./oorabona/node-liblzma/"
+  "mocha": {
+    "throw-deprecation": true,
+    "require": [
+      "coffeescript/register"
+    ],
+    "inline-diffs": true,
+    "timeout": 5000,
+    "reporter": "spec",
+    "recursive": true
   }
 }

package/scripts/download_extract_deps.py

@@ -0,0 +1,29 @@
+import urllib.request
+import sys
+import tarfile
+import os
+
+url = 'https://tukaani.org/xz/xz-5.2.5.tar.xz'
+tarball = os.path.abspath(sys.argv[1])
+dirname = os.path.abspath(sys.argv[2])
+
+def members(tf):
+    for member in tf.getmembers():
+        member.path = member.path.replace('xz-5.2.5', 'xz')
+        yield member
+
+# avoid redownload if tarball already exist
+if os.path.exists(tarball):
+    print('Not downloading file, tarball', tarball, 'already exists.')
+else:
+    print('Downloading archive from ', url)
+    with urllib.request.urlopen(url) as response:
+        with open(tarball, 'wb') as f:
+            f.write(response.read())
+
+tfile = tarfile.open(tarball,'r:xz')
+tfile.extractall(dirname, members=members(tfile))
+
+print('Finished extracting tarball to ', dirname)
+
+sys.exit(0)

package/scripts/prebuildify.py

@@ -0,0 +1,13 @@
+import os
+import shutil
+import sys
+
+source = os.path.abspath(sys.argv[1])
+target = os.path.abspath(sys.argv[2])
+
+# Create target directory
+target_dirname = os.path.dirname(target)
+os.makedirs(target_dirname, exist_ok=True)
+
+# We probably do not need the extra metadata info but that does not hurt
+shutil.copy2(source, target)

package/scripts/walk_sources.py

@@ -0,0 +1,7 @@
+import os;
+import sys;
+
+for (dirpath, dirnames, filenames) in os.walk(sys.argv[1]):
+    for filename in filenames:
+        if filename.endswith(('.cc', '.cpp', '.h', '.hpp', '.c')): 
+            print('/'.join([dirpath.replace(os.sep, '/'), filename]))

package/src/bindings/module.cpp

@@ -1,107 +1,107 @@
 /**
- * node-liblzma - Node.js bindings for liblzma
- * Copyright (C) 2014-2015 Olivier Orabona <olivier.orabona@gmail.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- **/
+	* node-liblzma - Node.js bindings for liblzma
+	* Copyright (C) 2014-2015 Olivier Orabona <olivier.orabona@gmail.com>
+	*
+	* This program is free software: you can redistribute it and/or modify
+	* it under the terms of the GNU Lesser General Public License as published by
+	* the Free Software Foundation, either version 3 of the License, or
+	* (at your option) any later version.
+	*
+	* This program is distributed in the hope that it will be useful,
+	* but WITHOUT ANY WARRANTY; without even the implied warranty of
+	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+	* GNU General Public License for more details.
+	*
+	* You should have received a copy of the GNU Lesser General Public License
+	* along with this program. If not, see <https://www.gnu.org/licenses/>.
+**/
 
 #include "node-liblzma.hpp"
 
-using namespace v8;
-
-void moduleInit(Local<Object> exports) {
-	LZMA::Init(exports);
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+	LZMA::Init(env, exports);
 
+	// Constants
 	// enum lzma_ret
-	exports->Set(NewString("LZMA_OK"),                Nan::New<Number>(LZMA_OK));
-	exports->Set(NewString("LZMA_STREAM_END"),        Nan::New<Number>(LZMA_STREAM_END));
-	exports->Set(NewString("LZMA_NO_CHECK"),          Nan::New<Number>(LZMA_NO_CHECK));
-	exports->Set(NewString("LZMA_UNSUPPORTED_CHECK"), Nan::New<Number>(LZMA_UNSUPPORTED_CHECK));
-	exports->Set(NewString("LZMA_GET_CHECK"),         Nan::New<Number>(LZMA_GET_CHECK));
-	exports->Set(NewString("LZMA_MEM_ERROR"),         Nan::New<Number>(LZMA_MEM_ERROR));
-	exports->Set(NewString("LZMA_MEMLIMIT_ERROR"),    Nan::New<Number>(LZMA_MEMLIMIT_ERROR));
-	exports->Set(NewString("LZMA_FORMAT_ERROR"),      Nan::New<Number>(LZMA_FORMAT_ERROR));
-	exports->Set(NewString("LZMA_OPTIONS_ERROR"),     Nan::New<Number>(LZMA_OPTIONS_ERROR));
-	exports->Set(NewString("LZMA_DATA_ERROR"),        Nan::New<Number>(LZMA_DATA_ERROR));
-	exports->Set(NewString("LZMA_BUF_ERROR"),         Nan::New<Number>(LZMA_BUF_ERROR));
-	exports->Set(NewString("LZMA_PROG_ERROR"),        Nan::New<Number>(LZMA_PROG_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_OK"), Napi::Number::New(env, LZMA_OK));
+	exports.Set(Napi::String::New(env, "LZMA_STREAM_END"), Napi::Number::New(env, LZMA_STREAM_END));
+	exports.Set(Napi::String::New(env, "LZMA_NO_CHECK"), Napi::Number::New(env, LZMA_NO_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_UNSUPPORTED_CHECK"), Napi::Number::New(env, LZMA_UNSUPPORTED_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_GET_CHECK"), Napi::Number::New(env, LZMA_GET_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_MEM_ERROR"), Napi::Number::New(env, LZMA_MEM_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_MEMLIMIT_ERROR"), Napi::Number::New(env, LZMA_MEMLIMIT_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_FORMAT_ERROR"), Napi::Number::New(env, LZMA_FORMAT_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_OPTIONS_ERROR"), Napi::Number::New(env, LZMA_OPTIONS_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_DATA_ERROR"), Napi::Number::New(env, LZMA_DATA_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_BUF_ERROR"), Napi::Number::New(env, LZMA_BUF_ERROR));
+	exports.Set(Napi::String::New(env, "LZMA_PROG_ERROR"), Napi::Number::New(env, LZMA_PROG_ERROR));
 
 	// enum lzma_action
-	exports->Set(NewString("LZMA_RUN"),        Nan::New<Number>(LZMA_RUN));
-	exports->Set(NewString("LZMA_SYNC_FLUSH"), Nan::New<Number>(LZMA_SYNC_FLUSH));
-	exports->Set(NewString("LZMA_FULL_FLUSH"), Nan::New<Number>(LZMA_FULL_FLUSH));
-	exports->Set(NewString("LZMA_FINISH"),     Nan::New<Number>(LZMA_FINISH));
+	exports.Set(Napi::String::New(env, "LZMA_RUN"), Napi::Number::New(env, LZMA_RUN));
+	exports.Set(Napi::String::New(env, "LZMA_SYNC_FLUSH"), Napi::Number::New(env, LZMA_SYNC_FLUSH));
+	exports.Set(Napi::String::New(env, "LZMA_FULL_FLUSH"), Napi::Number::New(env, LZMA_FULL_FLUSH));
+	exports.Set(Napi::String::New(env, "LZMA_FINISH"), Napi::Number::New(env, LZMA_FINISH));
 
 	// enum lzma_check
-	exports->Set(NewString("LZMA_CHECK_NONE"),   Nan::New<Number>(LZMA_CHECK_NONE));
-	exports->Set(NewString("LZMA_CHECK_CRC32"),  Nan::New<Number>(LZMA_CHECK_CRC32));
-	exports->Set(NewString("LZMA_CHECK_CRC64"),  Nan::New<Number>(LZMA_CHECK_CRC64));
-	exports->Set(NewString("LZMA_CHECK_SHA256"), Nan::New<Number>(LZMA_CHECK_SHA256));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_NONE"), Napi::Number::New(env, LZMA_CHECK_NONE));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_CRC32"), Napi::Number::New(env, LZMA_CHECK_CRC32));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_CRC64"), Napi::Number::New(env, LZMA_CHECK_CRC64));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_SHA256"), Napi::Number::New(env, LZMA_CHECK_SHA256));
 
 	// lzma_match_finder
-	exports->Set(NewString("MF_HC3"), Nan::New<Number>(LZMA_MF_HC3));
-	exports->Set(NewString("MF_HC4"), Nan::New<Number>(LZMA_MF_HC4));
-	exports->Set(NewString("MF_BT2"), Nan::New<Number>(LZMA_MF_BT2));
-	exports->Set(NewString("MF_BT3"), Nan::New<Number>(LZMA_MF_BT3));
-	exports->Set(NewString("MF_BT4"), Nan::New<Number>(LZMA_MF_BT4));
+	exports.Set(Napi::String::New(env, "MF_HC3"), Napi::Number::New(env, LZMA_MF_HC3));
+	exports.Set(Napi::String::New(env, "MF_HC4"), Napi::Number::New(env, LZMA_MF_HC4));
+	exports.Set(Napi::String::New(env, "MF_BT2"), Napi::Number::New(env, LZMA_MF_BT2));
+	exports.Set(Napi::String::New(env, "MF_BT3"), Napi::Number::New(env, LZMA_MF_BT3));
+	exports.Set(Napi::String::New(env, "MF_BT4"), Napi::Number::New(env, LZMA_MF_BT4));
 
 	// lzma_mode
-	exports->Set(NewString("LZMA_MODE_FAST"),   Nan::New<Number>(LZMA_MODE_FAST));
-	exports->Set(NewString("LZMA_MODE_NORMAL"), Nan::New<Number>(LZMA_MODE_NORMAL));
+	exports.Set(Napi::String::New(env, "LZMA_MODE_FAST"), Napi::Number::New(env, LZMA_MODE_FAST));
+	exports.Set(Napi::String::New(env, "LZMA_MODE_NORMAL"), Napi::Number::New(env, LZMA_MODE_NORMAL));
 
 	// defines
-	exports->Set(NewString("LZMA_FILTER_X86"),          Nan::New<Number>(LZMA_FILTER_X86));
-	exports->Set(NewString("LZMA_FILTER_POWERPC"),      Nan::New<Number>(LZMA_FILTER_POWERPC));
-	exports->Set(NewString("LZMA_FILTER_IA64"),         Nan::New<Number>(LZMA_FILTER_IA64));
-	exports->Set(NewString("LZMA_FILTER_ARM"),          Nan::New<Number>(LZMA_FILTER_ARM));
-	exports->Set(NewString("LZMA_FILTER_ARMTHUMB"),     Nan::New<Number>(LZMA_FILTER_ARMTHUMB));
-	exports->Set(NewString("LZMA_FILTER_SPARC"),        Nan::New<Number>(LZMA_FILTER_SPARC));
-	exports->Set(NewString("LZMA_FILTER_DELTA"),        Nan::New<Number>(LZMA_FILTER_DELTA));
-	exports->Set(NewString("LZMA_FILTERS_MAX"),         Nan::New<Number>(LZMA_FILTERS_MAX));
-	exports->Set(NewString("LZMA_FILTER_LZMA1"),        Nan::New<Number>(LZMA_FILTER_LZMA1));
-	exports->Set(NewString("LZMA_FILTER_LZMA2"),        Nan::New<Number>(LZMA_FILTER_LZMA2));
-	exports->Set(NewString("LZMA_VLI_UNKNOWN"),         Nan::New<Number>(LZMA_VLI_UNKNOWN));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_X86"), Napi::Number::New(env, LZMA_FILTER_X86));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_POWERPC"), Napi::Number::New(env, LZMA_FILTER_POWERPC));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_IA64"), Napi::Number::New(env, LZMA_FILTER_IA64));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_ARM"), Napi::Number::New(env, LZMA_FILTER_ARM));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_ARMTHUMB"), Napi::Number::New(env, LZMA_FILTER_ARMTHUMB));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_SPARC"), Napi::Number::New(env, LZMA_FILTER_SPARC));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_DELTA"), Napi::Number::New(env, LZMA_FILTER_DELTA));
+	exports.Set(Napi::String::New(env, "LZMA_FILTERS_MAX"), Napi::Number::New(env, LZMA_FILTERS_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_LZMA1"), Napi::Number::New(env, LZMA_FILTER_LZMA1));
+	exports.Set(Napi::String::New(env, "LZMA_FILTER_LZMA2"), Napi::Number::New(env, LZMA_FILTER_LZMA2));
+	exports.Set(Napi::String::New(env, "LZMA_VLI_UNKNOWN"), Napi::Number::New(env, LZMA_VLI_UNKNOWN));
+
+	exports.Set(Napi::String::New(env, "LZMA_VLI_BYTES_MAX"), Napi::Number::New(env, LZMA_VLI_BYTES_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_ID_MAX"), Napi::Number::New(env, LZMA_CHECK_ID_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_CHECK_SIZE_MAX"), Napi::Number::New(env, LZMA_CHECK_SIZE_MAX));
+	exports.Set(Napi::String::New(env, "LZMA_PRESET_DEFAULT"), Napi::Number::New(env, LZMA_PRESET_DEFAULT));
+	exports.Set(Napi::String::New(env, "LZMA_PRESET_LEVEL_MASK"), Napi::Number::New(env, LZMA_PRESET_LEVEL_MASK));
+	exports.Set(Napi::String::New(env, "LZMA_PRESET_EXTREME"), Napi::Number::New(env, LZMA_PRESET_EXTREME));
+	exports.Set(Napi::String::New(env, "LZMA_TELL_NO_CHECK"), Napi::Number::New(env, LZMA_TELL_NO_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_TELL_UNSUPPORTED_CHECK"), Napi::Number::New(env, LZMA_TELL_UNSUPPORTED_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_TELL_ANY_CHECK"), Napi::Number::New(env, LZMA_TELL_ANY_CHECK));
+	exports.Set(Napi::String::New(env, "LZMA_CONCATENATED"), Napi::Number::New(env, LZMA_CONCATENATED));
+	exports.Set(Napi::String::New(env, "LZMA_STREAM_HEADER_SIZE"), Napi::Number::New(env, LZMA_STREAM_HEADER_SIZE));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_MAJOR"), Napi::Number::New(env, LZMA_VERSION_MAJOR));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_MINOR"), Napi::Number::New(env, LZMA_VERSION_MINOR));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_PATCH"), Napi::Number::New(env, LZMA_VERSION_PATCH));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY"), Napi::Number::New(env, LZMA_VERSION_STABILITY));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY_ALPHA"), Napi::Number::New(env, LZMA_VERSION_STABILITY_ALPHA));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY_BETA"), Napi::Number::New(env, LZMA_VERSION_STABILITY_BETA));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STABILITY_STABLE"), Napi::Number::New(env, LZMA_VERSION_STABILITY_STABLE));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION"), Napi::Number::New(env, LZMA_VERSION));
+	exports.Set(Napi::String::New(env, "LZMA_VERSION_STRING"), Napi::String::New(env, LZMA_VERSION_STRING));
 
-	exports->Set(NewString("LZMA_VLI_BYTES_MAX"),            Nan::New<Number>(LZMA_VLI_BYTES_MAX));
-	exports->Set(NewString("LZMA_CHECK_ID_MAX"),             Nan::New<Number>(LZMA_CHECK_ID_MAX));
-	exports->Set(NewString("LZMA_CHECK_SIZE_MAX"),           Nan::New<Number>(LZMA_CHECK_SIZE_MAX));
-	exports->Set(NewString("LZMA_PRESET_DEFAULT"),           Nan::New<Number>(LZMA_PRESET_DEFAULT));
-	exports->Set(NewString("LZMA_PRESET_LEVEL_MASK"),        Nan::New<Number>(LZMA_PRESET_LEVEL_MASK));
-	exports->Set(NewString("LZMA_PRESET_EXTREME"),           Nan::New<Number>(LZMA_PRESET_EXTREME));
-	exports->Set(NewString("LZMA_TELL_NO_CHECK"),            Nan::New<Number>(LZMA_TELL_NO_CHECK));
-	exports->Set(NewString("LZMA_TELL_UNSUPPORTED_CHECK"),   Nan::New<Number>(LZMA_TELL_UNSUPPORTED_CHECK));
-	exports->Set(NewString("LZMA_TELL_ANY_CHECK"),           Nan::New<Number>(LZMA_TELL_ANY_CHECK));
-	exports->Set(NewString("LZMA_CONCATENATED"),             Nan::New<Number>(LZMA_CONCATENATED));
-	exports->Set(NewString("LZMA_STREAM_HEADER_SIZE"),       Nan::New<Number>(LZMA_STREAM_HEADER_SIZE));
-	exports->Set(NewString("LZMA_VERSION_MAJOR"),            Nan::New<Number>(LZMA_VERSION_MAJOR));
-	exports->Set(NewString("LZMA_VERSION_MINOR"),            Nan::New<Number>(LZMA_VERSION_MINOR));
-	exports->Set(NewString("LZMA_VERSION_PATCH"),            Nan::New<Number>(LZMA_VERSION_PATCH));
-	exports->Set(NewString("LZMA_VERSION_STABILITY"),        Nan::New<Number>(LZMA_VERSION_STABILITY));
-	exports->Set(NewString("LZMA_VERSION_STABILITY_ALPHA"),  Nan::New<Number>(LZMA_VERSION_STABILITY_ALPHA));
-	exports->Set(NewString("LZMA_VERSION_STABILITY_BETA"),   Nan::New<Number>(LZMA_VERSION_STABILITY_BETA));
-	exports->Set(NewString("LZMA_VERSION_STABILITY_STABLE"), Nan::New<Number>(LZMA_VERSION_STABILITY_STABLE));
-	exports->Set(NewString("LZMA_VERSION"),                  Nan::New<Number>(LZMA_VERSION));
-	exports->Set(NewString("LZMA_VERSION_STRING"),           NewString(LZMA_VERSION_STRING));
+	// LZMAStream flags
+	exports.Set(Napi::String::New(env, "STREAM_ENCODE"), Napi::Number::New(env, STREAM_ENCODE));
+	exports.Set(Napi::String::New(env, "STREAM_DECODE"), Napi::Number::New(env, STREAM_DECODE));
+	exports.Set(Napi::String::New(env, "STREAM_ENCODE_MT"), Napi::Number::New(env, STREAM_ENCODE_MT));
 
-  // LZMAStream flags
-  exports->Set(NewString("STREAM_ENCODE"),                  Nan::New<Number>(STREAM_ENCODE));
-  exports->Set(NewString("STREAM_DECODE"),                  Nan::New<Number>(STREAM_DECODE));
-#ifdef LIBLZMA_ENABLE_MT
-  exports->Set(NewString("STREAM_ENCODE_MT"),                  Nan::New<Number>(STREAM_ENCODE_MT));
-#endif
+	exports.Set(Napi::String::New(env, "BUFSIZ"), Napi::Number::New(env, BUFSIZ));
 
-  exports->Set(NewString("BUFSIZ"),                  Nan::New<Number>(BUFSIZ));
+	return exports;
 }
 
-NODE_MODULE(node_liblzma, moduleInit)
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)