cbor-extract 0.3.1 → 2.0.0

package/binding.gyp

@@ -1,18 +1,29 @@
 {
   "variables": {
       "os_linux_compiler%": "gcc",
+      "enable_v8%": "true",
+      "enable_pointer_compression%": "false",
       "build_v8_with_gn": "false"
   },
+  "conditions": [
+    ['OS=="win"', {
+      "variables": {
+        "enable_v8%": "<!(echo %ENABLE_V8_FUNCTIONS%)",
+      }
+    }],
+    ['OS!="win"', {
+      "variables": {
+        "enable_v8%": "<!(echo $ENABLE_V8_FUNCTIONS)",
+      }
+    }]
+  ],
   "targets": [
     {
-      "target_name": "cbor-extract",
-      "win_delay_load_hook": "false",
+      "target_name": "extract",
       "sources": [
         "src/extract.cpp",
       ],
-      "include_dirs": [
-        "<!(node -e \"require('nan')\")",
-      ],
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
       "conditions": [
         ["OS=='linux'", {
           "variables": {
@@ -40,6 +51,9 @@
             "-O3"
           ],
         }],
+        ["enable_v8!='false'", {
+          "defines": ["ENABLE_V8_API=1"]
+        }],
       ],
     }
   ]

package/index.js

@@ -1 +1 @@
-module.exports = require('node-gyp-build')(__dirname)
+module.exports = require('node-gyp-build-optional-packages')(__dirname)

package/package.json

@@ -1,22 +1,42 @@
-{
-  "name": "cbor-extract",
-  "author": "Kris Zyp",
-  "version": "0.3.1",
-  "description": "Node addon for string extraction for cbor-x",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "http://github.com/kriszyp/cbor-extract"
-  },
-  "scripts": {
-    "install": "node-gyp-build",
-    "recompile": "node-gyp build",
-    "test": "./node_modules/.bin/mocha tests/test*.js -u tdd"
-  },
-  "main": "./index.js",
-  "gypfile": true,
-  "dependencies": {
-    "nan": "^2.14.2",
-    "node-gyp-build": "^4.2.3"
-  }
-}
+{
+  "name": "cbor-extract",
+  "author": "Kris Zyp",
+  "version": "2.0.0",
+  "description": "Node addon for string extraction for cbor-x",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/kriszyp/cbor-extract"
+  },
+  "scripts": {
+    "install": "node-gyp-build-optional-packages",
+    "recompile": "node-gyp clean && node-gyp configure && node-gyp build",
+    "before-publish": "prebuildify-ci download && prebuildify --target 16.14.2 && set ENABLE_V8_FUNCTIONS=false&& prebuildify --platform-packages --napi --target 16.14.2 && node set-optional-deps.cjs",
+    "prebuild": "prebuildify --target 16.14.2",
+    "prebuild-libc": "prebuildify --tag-libc --target 16.14.2 && ENABLE_V8_FUNCTIONS=false prebuildify --platform-packages --napi --tag-libc --target 16.14.2",
+    "publish-all": "cd prebuilds/win32-x64 && npm publish --access public && cd ../darwin-x64 && npm publish --access public && cd ../darwin-arm64 && npm publish --access public && cd ../linux-x64 && npm publish --access public && cd ../linux-arm64 && npm publish --access public  && cd ../linux-arm && npm publish --access public && cd ../.. && npm publish --access public",
+    "test": "node ./index.js"
+  },
+  "main": "./index.js",
+  "gypfile": true,
+  "dependencies": {
+    "node-gyp-build-optional-packages": "5.0.1"
+  },
+  "files": [
+    "index.js",
+    "/src",
+    "/*.gyp"
+  ],
+  "devDependencies": {
+    "prebuildify": "kriszyp/prebuildify#optional-packages",
+    "prebuildify-ci": "^1.0.5"
+  },
+  "optionalDependencies": {
+    "@cbor-extract/cbor-extract-darwin-arm64": "2.0.0",
+    "@cbor-extract/cbor-extract-darwin-x64": "2.0.0",
+    "@cbor-extract/cbor-extract-linux-arm": "2.0.0",
+    "@cbor-extract/cbor-extract-linux-arm64": "2.0.0",
+    "@cbor-extract/cbor-extract-linux-x64": "2.0.0",
+    "@cbor-extract/cbor-extract-win32-x64": "2.0.0"
+  }
+}

package/src/extract.cpp

@@ -5,11 +5,10 @@ provides much better performance. This will parse and produce up to 256 strings
 times as necessary to get more strings. This must be partially capable of parsing CBOR so it can know where to
 find the string tokens and determine their position and length. All strings are decoded as UTF-8.
 */
+#include <node_api.h>
+#if ENABLE_V8_API
 #include <v8.h>
-#include <node.h>
-#include <node_buffer.h>
-#include <nan.h>
-using namespace v8;
+#endif
 
 #ifndef thread_local
 #ifdef __GNUC__
@@ -24,18 +23,23 @@ using namespace v8;
 #endif
 
 const int MAX_TARGET_SIZE = 255;
-
+napi_value unexpectedEnd(napi_env env) {
+	napi_value returnValue;
+	napi_get_undefined(env, &returnValue);
+	napi_throw_type_error(env, NULL, "Unexpected end of buffer reading string");
+	return returnValue;
+}
 class Extractor {
 public:
-	v8::Local<v8::Value> target[MAX_TARGET_SIZE + 1]; // leave one for the queued string
+	napi_value target[MAX_TARGET_SIZE + 1]; // leave one for the queued string
 
 	uint8_t* source;
 	int position = 0;
 	int writePosition = 0;
 	int stringStart = 0;
 	int lastStringEnd = 0;
-	Isolate *isolate = Isolate::GetCurrent();
-	void readString(int length, bool allowStringBlocks) {
+
+	void readString(napi_env env, int length, bool allowStringBlocks) {
 		int start = position;
 		int end = position + length;
 		if (allowStringBlocks) { // for larger strings, we don't bother to check every character for being latin, and just go right to creating a new string
@@ -50,18 +54,24 @@ public:
 		if (position < end) {
 			// non-latin character
 			if (lastStringEnd) {
-				target[writePosition++] = String::NewFromOneByte(isolate,  (uint8_t*) source + stringStart, v8::NewStringType::kNormal, lastStringEnd - stringStart).ToLocalChecked();
+				napi_value value;
+				napi_create_string_latin1(env, (const char*) source + stringStart, lastStringEnd - stringStart, &value);
+				target[writePosition++] = value;
 				lastStringEnd = 0;
 			}
 			// use standard utf-8 conversion
-			target[writePosition++] = Nan::New<v8::String>((char*) source + start, (int) length).ToLocalChecked();
+			napi_value value;
+			napi_create_string_utf8(env, (const char*) source + start, (int) length, &value);
+			target[writePosition++] = value;
 			position = end;
 			return;
 		}
 
 		if (lastStringEnd) {
 			if (start - lastStringEnd > 40 || end - stringStart > 6000) {
-				target[writePosition++] = String::NewFromOneByte(isolate, (uint8_t*) source + stringStart, v8::NewStringType::kNormal, lastStringEnd - stringStart).ToLocalChecked();
+				napi_value value;
+				napi_create_string_latin1(env, (const char*) source + stringStart, lastStringEnd - stringStart, &value);
+				target[writePosition++] = value;
 				stringStart = start;
 			}
 		} else {
@@ -69,13 +79,12 @@ public:
 		}
 		lastStringEnd = end;
 	}
-
-	Local<Value> extractStrings(int startingPosition, int size, int firstStringSize, uint8_t* inputSource) {
+	napi_value extractStrings(napi_env env, int startingPosition, int size, int firstStringSize, uint8_t* inputSource) {
 		writePosition = 0;
 		lastStringEnd = 0;
 		position = startingPosition;
 		source = inputSource;
-		readString(firstStringSize, firstStringSize < 0x100);
+		readString(env, firstStringSize, firstStringSize < 0x100);
 		while (position < size) {
 			uint8_t token = source[position++];
 			uint8_t majorType = token >> 5;
@@ -85,23 +94,20 @@ public:
 				switch (token) {
 					case 0x18:
 						if (position + 1 > size) {
-							Nan::ThrowError("Unexpected end of buffer reading string");
-							return Nan::Null();
+							return unexpectedEnd(env);
 						}
 						length = source[position++];
 						break;
 					case 0x19:
 						if (position + 2 > size) {
-							Nan::ThrowError("Unexpected end of buffer reading string");
-							return Nan::Null();
+							return unexpectedEnd(env);
 						}
 						length = source[position++] << 8;
 						length += source[position++];
 						break;
 					case 0x1a:
 						if (position + 4 > size) {
-							Nan::ThrowError("Unexpected end of buffer reading string");
-							return Nan::Null();
+							return unexpectedEnd(env);
 						}
 						length = source[position++] << 24;
 						length += source[position++] << 16;
@@ -109,19 +115,16 @@ public:
 						length += source[position++];
 						break;
 					case 0x1b:
-						Nan::ThrowError("Unexpected end of buffer reading string");
-						return Nan::Null();
-						break;
+						return unexpectedEnd(env);
 					default:
 						length = token;
 				}
 				if (majorType == 3) {
 					// string
 					if (length + position > size) {
-						Nan::ThrowError("Unexpected end of buffer reading string");
-						return Nan::Null();
+						return unexpectedEnd(env);
 					}
-					readString(length, length < 0x100);
+					readString(env, length, length < 0x100);
 					if (writePosition >= MAX_TARGET_SIZE)
 						break;
 				} else { // binary data
@@ -145,48 +148,50 @@ public:
 				}
 			}
 		}
-
 		if (lastStringEnd) {
-			if (writePosition == 0)
-				return String::NewFromOneByte(isolate, (uint8_t*) source + stringStart, v8::NewStringType::kNormal, lastStringEnd - stringStart).ToLocalChecked();
-			target[writePosition++] = String::NewFromOneByte(isolate, (uint8_t*) source + stringStart, v8::NewStringType::kNormal, lastStringEnd - stringStart).ToLocalChecked();
+			napi_value value;
+			napi_create_string_latin1(env, (const char*) source + stringStart, lastStringEnd - stringStart, &value);
+			if (writePosition == 0) {
+				return value;
+			}
+			target[writePosition++] = value;
 		} else if (writePosition == 1) {
 			return target[0];
 		}
-#if NODE_VERSION_AT_LEAST(12,0,0)
-		return Array::New(isolate, target, writePosition);
-#else
-		Local<Array> array = Array::New(isolate, writePosition);
-		Local<Context> context = Nan::GetCurrentContext();
+		napi_value array;
+		#if ENABLE_V8_API
+		v8::Local<v8::Array> v8Array = v8::Array::New(v8::Isolate::GetCurrent(), (v8::Local<v8::Value>*) target, writePosition);
+		memcpy(&array, &v8Array, sizeof(array));
+		#else
+		napi_create_array_with_length(env, writePosition, &array);
 		for (int i = 0; i < writePosition; i++) {
-			array->Set(context, i, target[i]);
+			napi_set_element(env, array, i, target[i]);
 		}
+		#endif
 		return array;
-#endif
 	}
 };
 
 static thread_local Extractor* extractor;
 
-NAN_METHOD(extractStrings) {
-	Local<Context> context = Nan::GetCurrentContext();
-	int position = Local<Number>::Cast(info[0])->IntegerValue(context).FromJust();
-	int size = Local<Number>::Cast(info[1])->IntegerValue(context).FromJust();
-	int firstStringSize = Local<Number>::Cast(info[2])->IntegerValue(context).FromJust();
-	if (info[3]->IsArrayBufferView()) {
-		uint8_t* source = (uint8_t*) node::Buffer::Data(info[3]);
-		info.GetReturnValue().Set(extractor->extractStrings(position, size, firstStringSize, source));
-	}
-}
-
-NAN_METHOD(isOneByte) {
-	info.GetReturnValue().Set(Nan::New<Boolean>(Local<String>::Cast(info[0])->IsOneByte()));
+napi_value extractStrings(napi_env env, napi_callback_info info) {
+	size_t argc = 4;
+	napi_value args[4];
+	napi_get_cb_info(env, info, &argc, args, NULL, NULL);
+	uint32_t position;
+	uint32_t size;
+	uint32_t firstStringSize;
+	napi_get_value_uint32(env, args[0], &position);
+	napi_get_value_uint32(env, args[1], &size);
+	napi_get_value_uint32(env, args[2], &firstStringSize);
+	uint8_t* source;
+	napi_get_typedarray_info(env, args[3], NULL, NULL, (void**) &source, NULL, NULL);
+	return extractor->extractStrings(env, position, size, firstStringSize, source);
 }
+#define EXPORT_NAPI_FUNCTION(name, func) { napi_property_descriptor desc = { name, 0, func, 0, 0, 0, (napi_property_attributes) (napi_writable | napi_configurable), 0 }; napi_define_properties(env, exports, 1, &desc); }
 
-void initializeModule(v8::Local<v8::Object> exports) {
+NAPI_MODULE_INIT() {
 	extractor = new Extractor(); // create our thread-local extractor
-	Nan::SetMethod(exports, "extractStrings", extractStrings);
-	Nan::SetMethod(exports, "isOneByte", isOneByte);
-}
-
-NODE_MODULE_CONTEXT_AWARE(extractor, initializeModule);
+	EXPORT_NAPI_FUNCTION("extractStrings", extractStrings);
+	return exports;
+}