emnapi 1.9.2 → 2.0.0-alpha.1

package/cmake/wasm32.cmake

@@ -1,8 +1,5 @@
 # Cmake toolchain description file for the Makefile
 
-# This is arbitrary, AFAIK, for now.
-cmake_minimum_required(VERSION 3.4.0)
-
 set(CMAKE_SYSTEM_NAME WASM)
 set(CMAKE_SYSTEM_VERSION 1)
 set(CMAKE_SYSTEM_PROCESSOR wasm32)

package/common.gypi

@@ -11,6 +11,7 @@
     'max_memory%': 2147483648,
     # must be an absolute path
     'emnapi_js_library%': '<!(node -p "path.resolve(process.argv[1],\'dist/library_napi.js\').replace(process.argv[2],\'/\')" "<(node_root_dir)" "\\\\")',
+    'v8_js_library%': '<!(node -p "path.resolve(process.argv[1],\'dist/library_v8.js\').replace(process.argv[2],\'/\')" "<(node_root_dir)" "\\\\")',
     'emnapi_manual_linking%': 0,
   },
 
@@ -20,6 +21,7 @@
     'defines': [
       'BUILDING_NODE_EXTENSION',
       '__STDC_FORMAT_MACROS',
+      'V8_ENABLE_DIRECT_LOCAL',
     ],
 
     'cflags': [
@@ -81,7 +83,7 @@
         ],
         'ldflags': [
           "-sALLOW_MEMORY_GROWTH=1",
-          "-sEXPORTED_FUNCTIONS=['_malloc','_free','_napi_register_wasm_v1','_node_api_module_get_api_version_v1']",
+          "-sEXPORTED_FUNCTIONS=['_malloc','_free']",
           '-sNODEJS_CATCH_EXIT=0',
           '-sNODEJS_CATCH_REJECTION=0',
           '-sWASM_BIGINT=1',
@@ -98,7 +100,7 @@
           ],
           'OTHER_LDFLAGS': [
             "-sALLOW_MEMORY_GROWTH=1",
-            "-sEXPORTED_FUNCTIONS=['_malloc','_free','_napi_register_wasm_v1','_node_api_module_get_api_version_v1']",
+            "-sEXPORTED_FUNCTIONS=['_malloc','_free']",
             '-sNODEJS_CATCH_EXIT=0',
             '-sNODEJS_CATCH_REJECTION=0',
             '-sWASM_BIGINT=1',
@@ -176,11 +178,11 @@
                 'conditions': [
                   ['wasm_threads != 0', {
                     # wasi-threads
-                    'cflags': [ '--target=wasm64-wasi-threads', '-pthread' ],
-                    'ldflags': [ '--target=wasm64-wasi-threads', '-pthread' ],
+                    'cflags': [ '--target=wasm64-wasip1-threads', '-pthread' ],
+                    'ldflags': [ '--target=wasm64-wasip1-threads', '-pthread' ],
                     'xcode_settings': {
-                      'WARNING_CFLAGS': [ '--target=wasm64-wasi-threads', '-pthread' ],
-                      'OTHER_LDFLAGS': [ '--target=wasm64-wasi-threads', '-pthread' ],
+                      'WARNING_CFLAGS': [ '--target=wasm64-wasip1-threads', '-pthread' ],
+                      'OTHER_LDFLAGS': [ '--target=wasm64-wasip1-threads', '-pthread' ],
                     },
                   }, {
                     # wasi
@@ -196,11 +198,11 @@
                 'conditions': [
                   ['wasm_threads != 0', {
                     # wasi-threads
-                    'cflags': [ '--target=wasm32-wasi-threads', '-pthread' ],
-                    'ldflags': [ '--target=wasm32-wasi-threads', '-pthread' ],
+                    'cflags': [ '--target=wasm32-wasip1-threads', '-pthread' ],
+                    'ldflags': [ '--target=wasm32-wasip1-threads', '-pthread' ],
                     'xcode_settings': {
-                      'WARNING_CFLAGS': [ '--target=wasm32-wasi-threads', '-pthread' ],
-                      'OTHER_LDFLAGS': [ '--target=wasm32-wasi-threads', '-pthread' ],
+                      'WARNING_CFLAGS': [ '--target=wasm32-wasip1-threads', '-pthread' ],
+                      'OTHER_LDFLAGS': [ '--target=wasm32-wasip1-threads', '-pthread' ],
                     },
                   }, {
                     # wasi
@@ -246,7 +248,7 @@
                   '-Wl,--export-dynamic',
                   '-Wl,--export=malloc',
                   '-Wl,--export=free',
-                  '-Wl,--export=napi_register_wasm_v1',
+                  '-Wl,--export-if-defined=napi_register_wasm_v1',
                   '-Wl,--export-if-defined=node_api_module_get_api_version_v1',
                   '-Wl,--import-undefined',
                   '-Wl,--export-table',
@@ -259,7 +261,7 @@
                     '-Wl,--export-dynamic',
                     '-Wl,--export=malloc',
                     '-Wl,--export=free',
-                    '-Wl,--export=napi_register_wasm_v1',
+                    '-Wl,--export-if-defined=napi_register_wasm_v1',
                     '-Wl,--export-if-defined=node_api_module_get_api_version_v1',
                     '-Wl,--import-undefined',
                     '-Wl,--export-table',
@@ -335,7 +337,7 @@
                   '-Wl,--export-dynamic',
                   '-Wl,--export=malloc',
                   '-Wl,--export=free',
-                  '-Wl,--export=napi_register_wasm_v1',
+                  '-Wl,--export-if-defined=napi_register_wasm_v1',
                   '-Wl,--export-if-defined=node_api_module_get_api_version_v1',
                   '-Wl,--import-undefined',
                   '-Wl,--export-table',
@@ -348,7 +350,7 @@
                     '-Wl,--export-dynamic',
                     '-Wl,--export=malloc',
                     '-Wl,--export=free',
-                    '-Wl,--export=napi_register_wasm_v1',
+                    '-Wl,--export-if-defined=napi_register_wasm_v1',
                     '-Wl,--export-if-defined=node_api_module_get_api_version_v1',
                     '-Wl,--import-undefined',
                     '-Wl,--export-table',

package/dist/library_async_work.js

@@ -0,0 +1,390 @@
+//#region src/emscripten/init.ts
+/* eslint-disable @stylistic/indent */
+var emnapiCtx$1 = undefined;
+var emnapiEnv$1 = undefined;
+// export var emnapiRuntimeModuleExports: any = undefined!
+var emnapiNodeBinding$1 = undefined;
+var emnapiAsyncWorkPoolSize$1 = 0;
+const emnapiModule = {
+    exports: {},
+    loaded: false,
+    filename: ''
+};
+/**
+ * @__deps emnapi_create_env
+ * @__deps emnapi_delete_env
+ */
+function emnapiInit(options) {
+    if (emnapiModule.loaded)
+        return emnapiModule.exports;
+    if (typeof options !== 'object' || options === null) {
+        throw new TypeError('Invalid emnapi init option');
+    }
+    const context = options.context;
+    if (typeof context !== 'object' || context === null) {
+        throw new TypeError("Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`");
+    }
+    emnapiCtx$1 = context;
+    const filename = typeof options.filename === 'string' ? options.filename : '';
+    emnapiModule.filename = filename;
+    if ('nodeBinding' in options) {
+        const nodeBinding = options.nodeBinding;
+        if (typeof nodeBinding !== 'object' || nodeBinding === null) {
+            throw new TypeError('Invalid `options.nodeBinding`. Use @emnapi/node-binding package');
+        }
+        emnapiNodeBinding$1 = nodeBinding;
+    }
+    if ('asyncWorkPoolSize' in options) {
+        if (typeof options.asyncWorkPoolSize !== 'number') {
+            throw new TypeError('options.asyncWorkPoolSize must be a integer');
+        }
+        emnapiAsyncWorkPoolSize$1 = options.asyncWorkPoolSize >> 0;
+        if (emnapiAsyncWorkPoolSize$1 > 1024) {
+            emnapiAsyncWorkPoolSize$1 = 1024;
+        }
+        else if (emnapiAsyncWorkPoolSize$1 < -1024) {
+            emnapiAsyncWorkPoolSize$1 = -1024;
+        }
+    }
+    const NODE_MODULE_VERSION = 127 /* Version.NODE_MODULE_VERSION */;
+    const nodeRegisterModuleSymbol = `node_register_module_v${NODE_MODULE_VERSION}`;
+    const emscriptenExportedSymbol = `_${nodeRegisterModuleSymbol}`;
+    if (typeof Module[emscriptenExportedSymbol] === 'function') {
+        const scope = emnapiCtx$1.isolate.openScope();
+        try {
+            const exports = emnapiModule.exports;
+            const exportsHandle = scope.add(exports);
+            const moduleHandle = scope.add(emnapiModule);
+            Module[emscriptenExportedSymbol]({{{ to64('exportsHandle') }}}, {{{ to64('moduleHandle') }}}, {{{ to64('5') }}});
+        }
+        catch (err) {
+            if (err !== 'unwind') {
+                throw err;
+            }
+        }
+        finally {
+            emnapiCtx$1.isolate.closeScope(scope);
+        }
+        emnapiModule.loaded = true;
+        delete emnapiModule.envObject;
+        return emnapiModule.exports;
+    }
+    const find = Object.keys(Module).filter(k => k.startsWith('_node_register_module_v'));
+    if (find.length > 0) {
+        throw new Error(`The module${emnapiModule.filename ? ` '${emnapiModule.filename}'` : ''}
+was compiled against a different Node.js version using
+NODE_MODULE_VERSION ${find[0].slice(23)}. This version of Node.js requires
+NODE_MODULE_VERSION ${NODE_MODULE_VERSION}.`);
+    }
+    const moduleApiVersion = Module._node_api_module_get_api_version_v1();
+    const envObject = emnapiModule.envObject || (() => {
+        let address = _emnapi_create_env();
+        {{{ from64('address') }}};
+        address += 8;
+        const envObject = emnapiModule.envObject = emnapiEnv$1 = emnapiCtx$1.createEnv(filename, moduleApiVersion, {
+            address,
+            deleteEnv: (ptr) => {
+                _emnapi_delete_env({{{ to64('ptr') }}} - {{{ to64('8') }}});
+            },
+            setLastError(env, error_code, engine_error_code, engine_reserved) {
+                {{{ from64('env') }}};
+                env -= 8;
+                {{{ from64('engine_reserved') }}};
+#if MEMORY64
+                {{{ makeSetValue('env', 60 /* NapiEnvOffset64.last_error_error_code */, 'error_code', 'i32') }}};
+                {{{ makeSetValue('env', 56 /* NapiEnvOffset64.last_error_engine_error_code */, 'engine_error_code', 'u32') }}};
+                {{{ makeSetValue('env', 48 /* NapiEnvOffset64.last_error_engine_reserved */, 'engine_reserved', '*') }}};
+#else
+                {{{ makeSetValue('env', 40 /* NapiEnvOffset32.last_error_error_code */, 'error_code', 'i32') }}};
+                {{{ makeSetValue('env', 36 /* NapiEnvOffset32.last_error_engine_error_code */, 'engine_error_code', 'u32') }}};
+                {{{ makeSetValue('env', 32 /* NapiEnvOffset32.last_error_engine_reserved */, 'engine_reserved', '*') }}};
+#endif
+                return error_code;
+            },
+            makeDynCall_vppp: (cb) => {{{ makeDynCall('vppp', 'cb') }}},
+            makeDynCall_vp: (cb) => {{{ makeDynCall('vp', 'cb') }}},
+            abort
+        }, emnapiNodeBinding$1);
+#if MEMORY64
+        {{{ makeSetValue('address - 8', 32 /* NapiEnvOffset64.id */, 'envObject.id', 'u32') }}};
+#else
+        {{{ makeSetValue('address - 8', 24 /* NapiEnvOffset32.id */, 'envObject.id', 'u32') }}};
+#endif
+        return envObject;
+    })();
+    const scope = emnapiCtx$1.openScope(envObject);
+    try {
+        envObject.callIntoModule((envObject) => {
+            const exports = emnapiModule.exports;
+            const env = envObject.bridge.address;
+            const exportsHandle = scope.add(exports);
+            const napiValue = Module._napi_register_wasm_v1({{{ to64('env') }}}, {{{ to64('exportsHandle') }}});
+            emnapiModule.exports = (!napiValue) ? exports : emnapiCtx$1.jsValueFromNapiValue(napiValue);
+        });
+    }
+    catch (err) {
+        if (err !== 'unwind') {
+            throw err;
+        }
+    }
+    finally {
+        emnapiCtx$1.closeScope(envObject, scope);
+    }
+    emnapiModule.loaded = true;
+    delete emnapiModule.envObject;
+    return emnapiModule.exports;
+}
+/**
+ * @__sig i
+ */
+function _emnapi_async_work_pool_size() {
+    return Math.abs(emnapiAsyncWorkPoolSize$1);
+}
+//#endregion src/emscripten/init.ts
+//#region src/async-work.ts
+/**
+ * @__deps $emnapiCtx
+ * @__deps $emnapiEnv
+ * @__deps $emnapiNodeBinding
+ * @__deps $emnapiAsyncWorkPoolSize
+ * @__postset
+ * ```
+ * emnapiAWST.init();
+ * ```
+ */
+var emnapiAWST = {
+    idGen: {},
+    values: [undefined],
+    queued: new Set(),
+    pending: [],
+    init: function () {
+        const idGen = {
+            nextId: 1,
+            list: [],
+            generate: function () {
+                let id;
+                if (idGen.list.length) {
+                    id = idGen.list.shift();
+                }
+                else {
+                    id = idGen.nextId;
+                    idGen.nextId++;
+                }
+                return id;
+            },
+            reuse: function (id) {
+                idGen.list.push(id);
+            }
+        };
+        emnapiAWST.idGen = idGen;
+        emnapiAWST.values = [undefined];
+        emnapiAWST.queued = new Set();
+        emnapiAWST.pending = [];
+    },
+    create: function (env, resource, resourceName, execute, complete, data) {
+        let asyncId = 0;
+        let triggerAsyncId = 0;
+        if (emnapiNodeBinding) {
+            const asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resourceName, -1);
+            asyncId = asyncContext.asyncId;
+            triggerAsyncId = asyncContext.triggerAsyncId;
+        }
+        const id = emnapiAWST.idGen.generate();
+        emnapiAWST.values[id] = {
+            env,
+            id,
+            resource,
+            asyncId,
+            triggerAsyncId,
+            status: 0,
+            execute,
+            complete,
+            data
+        };
+        return id;
+    },
+    callComplete: function (work, status) {
+        const complete = work.complete;
+        const env = work.env;
+        const data = work.data;
+        const callback = () => {
+            if (!complete)
+                return;
+            const envObject = emnapiEnv$1;
+            const scope = emnapiCtx.openScope(envObject);
+            try {
+                envObject.callbackIntoModule(true, () => {
+                    {{{ makeDynCall('vpip', 'complete') }}}(env, status, data);
+                });
+            }
+            finally {
+                emnapiCtx.closeScope(envObject, scope);
+            }
+        };
+        if (emnapiNodeBinding) {
+            emnapiNodeBinding.node.makeCallback(work.resource, callback, [], {
+                asyncId: work.asyncId,
+                triggerAsyncId: work.triggerAsyncId
+            });
+        }
+        else {
+            callback();
+        }
+    },
+    queue: function (id) {
+        const work = emnapiAWST.values[id];
+        if (!work)
+            return;
+        if (work.status === 0) {
+            work.status = 1;
+            if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) {
+                emnapiAWST.pending.push(id);
+                return;
+            }
+            emnapiAWST.queued.add(id);
+            const env = work.env;
+            const data = work.data;
+            const execute = work.execute;
+            work.status = 2;
+            emnapiCtx.features.setImmediate(() => {
+                {{{ makeDynCall('vpp', 'execute') }}}(env, data);
+                emnapiAWST.queued.delete(id);
+                work.status = 3;
+                emnapiCtx.features.setImmediate(() => {
+                    emnapiAWST.callComplete(work, 0 /* napi_status.napi_ok */);
+                });
+                if (emnapiAWST.pending.length > 0) {
+                    const nextWorkId = emnapiAWST.pending.shift();
+                    emnapiAWST.values[nextWorkId].status = 0;
+                    emnapiAWST.queue(nextWorkId);
+                }
+            });
+        }
+    },
+    cancel: function (id) {
+        const index = emnapiAWST.pending.indexOf(id);
+        if (index !== -1) {
+            const work = emnapiAWST.values[id];
+            if (work && (work.status === 1)) {
+                work.status = 4;
+                emnapiAWST.pending.splice(index, 1);
+                emnapiCtx.features.setImmediate(() => {
+                    emnapiAWST.callComplete(work, 11 /* napi_status.napi_cancelled */);
+                });
+                return 0 /* napi_status.napi_ok */;
+            }
+            else {
+                return 9 /* napi_status.napi_generic_failure */;
+            }
+        }
+        return 9 /* napi_status.napi_generic_failure */;
+    },
+    remove: function (id) {
+        const work = emnapiAWST.values[id];
+        if (!work)
+            return;
+        if (emnapiNodeBinding) {
+            emnapiNodeBinding.node.emitAsyncDestroy({
+                asyncId: work.asyncId,
+                triggerAsyncId: work.triggerAsyncId
+            });
+        }
+        emnapiAWST.values[id] = undefined;
+        emnapiAWST.idGen.reuse(id);
+    }
+};
+//#endregion src/async-work.ts
+//#region src/macro.ts
+//#endregion src/macro.ts
+//#region src/emscripten/async-work.ts
+/**
+ * @__deps $emnapiCtx
+ * @__deps $emnapiEnv
+ * @__sig ippppppp
+ */
+function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    // @ts-expect-error
+    const envObject = emnapiEnv;
+    envObject.checkGCAccess();
+    if (!execute)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    if (!result)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    let resourceObject;
+    if (resource) {
+        resourceObject = Object(emnapiCtx.jsValueFromNapiValue(resource));
+    }
+    else {
+        resourceObject = {};
+    }
+    if (!resource_name)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    const resourceName = String(emnapiCtx.jsValueFromNapiValue(resource_name));
+    const id = emnapiAWST.create(env, resourceObject, resourceName, execute, complete, data);
+    {{{ from64('result') }}};
+    {{{ makeSetValue('result', 0, 'id', '*') }}};
+    return envObject.clearLastError();
+}
+/**
+ * @__deps $emnapiCtx
+ * @__sig ipp
+ */
+function _napi_delete_async_work(env, work) {
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    // @ts-expect-error
+    const envObject = emnapiEnv;
+    envObject.checkGCAccess();
+    if (!work)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAWST.remove(work);
+    return envObject.clearLastError();
+}
+/**
+ * @__deps $emnapiCtx
+ * @__sig ipp
+ */
+function _napi_queue_async_work(env, work) {
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    const envObject = emnapiEnv;
+    if (!work)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAWST.queue(work);
+    return envObject.clearLastError();
+}
+/**
+ * @__deps $emnapiCtx
+ * @__sig ipp
+ */
+function _napi_cancel_async_work(env, work) {
+    if (!env)
+        return 1 /* napi_status.napi_invalid_arg */;
+    const envObject = emnapiEnv;
+    if (!work)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    const status = emnapiAWST.cancel(work);
+    if (status === 0 /* napi_status.napi_ok */)
+        return envObject.clearLastError();
+    return envObject.setLastError(status);
+}
+(typeof addToLibrary === "function" ? addToLibrary : (...args) => mergeInto(LibraryManager.library, ...args))({
+    $emnapiEnv$1: "undefined",
+    $emnapiAWST: emnapiAWST,
+    $emnapiAWST__deps: ["$emnapiEnv$1", "$emnapiCtx", "$emnapiEnv", "$emnapiNodeBinding", "$emnapiAsyncWorkPoolSize"],
+    $emnapiAWST__postset: "emnapiAWST.init();",
+    napi_cancel_async_work: _napi_cancel_async_work,
+    napi_cancel_async_work__deps: ["$emnapiAWST", "$emnapiCtx"],
+    napi_cancel_async_work__sig: "ipp",
+    napi_create_async_work: _napi_create_async_work,
+    napi_create_async_work__deps: ["$emnapiAWST", "$emnapiCtx", "$emnapiEnv"],
+    napi_create_async_work__sig: "ippppppp",
+    napi_delete_async_work: _napi_delete_async_work,
+    napi_delete_async_work__deps: ["$emnapiAWST", "$emnapiCtx"],
+    napi_delete_async_work__sig: "ipp",
+    napi_queue_async_work: _napi_queue_async_work,
+    napi_queue_async_work__deps: ["$emnapiAWST", "$emnapiCtx"],
+    napi_queue_async_work__sig: "ipp"
+});