@ohos-ports/weak-napi 2.0.2-beta.0 → 2.0.2-beta.1

package/package.json

@@ -17,7 +17,7 @@
     "callback",
     "napi"
   ],
-  "version": "2.0.2-beta.0",
+  "version": "2.0.2-beta.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/ohos-ports/ohos-ports.git",
@@ -27,7 +27,8 @@
   "scripts": {
     "test": "nyc mocha --expose-gc",
     "install": "node-gyp-build",
-    "prebuild": "prebuildify --napi --tag-armv --tag-uv"
+    "prebuild": "prebuildify --napi --tag-armv --tag-uv",
+    "prepack": "prebuildify-ci download && ([ $(ls prebuilds | wc -l) = '5' ] || (echo 'Some prebuilds are missing'; exit 1))"
   },
   "dependencies": {
     "node-addon-api": "^3.0.0",
@@ -44,12 +45,11 @@
     "url": "https://github.com/ohos-ports/ohos-ports/issues"
   },
   "files": [
-    "lib/",
-    "src/",
-    "test/",
-    "prebuilds/",
-    "build/Release/weakref.node",
+    "lib",
+    "src",
     "binding.gyp",
+    "build/Release/weakref.node",
+    "prebuilds/",
     "LICENSE",
     "README.md",
     "History.md"

package/src/weakref.cc

@@ -5,21 +5,6 @@ using namespace Napi;
 
 namespace {
 
-// Node.js v12+ (and the ohos node v26.8.1 runtime) uses V8 incremental
-// finalization: weak-reference finalizers can run while the environment is
-// being torn down at process exit, after the libuv loop has stopped. At that
-// point calling SetImmediate() below would install fresh uv_check_t/uv_idle_t
-// handles onto a dead event loop and invoke into a finalizing napi_env,
-// crashing the process (use-after-free, SIGSEGV). napi_add_env_cleanup_hook
-// gives us a reliable signal that the environment is shutting down; once it
-// is set we drop the pending weak callback instead of scheduling it. This is
-// safe: the process is exiting and the callback would never run anyway.
-bool g_env_tearing_down = false;
-
-void OnEnvTeardown(void* /*arg*/) {
-  g_env_tearing_down = true;
-}
-
 class ObjectInfo : public ObjectWrap<ObjectInfo> {
  public:
   ObjectInfo(const CallbackInfo& args) : ObjectWrap(args) {
@@ -33,21 +18,10 @@ class ObjectInfo : public ObjectWrap<ObjectInfo> {
   }
 
   void OnFree() {
-    if (g_env_tearing_down)
-      return;
     SetImmediate(Env(), [this]() {
       callback_.MakeCallback(Value(), {});
       callback_.Reset();
-      // Release the strong persistent reference so the JS ObjectInfo wrapper
-      // becomes collectible (the JS Proxy created by lib/weak.js keeps it
-      // alive as long as the user holds it). We must NOT use Reset() here:
-      // napi_delete_reference() frees the internal Reference record while the
-      // object's private "wrapper" property still points at it, so any later
-      // napi_unwrap() on the live object would dereference freed memory and
-      // crash (observed as SIGSEGV on Node v26.8.1). Unref() drops the
-      // reference count to zero; the ObjectWrap finalizer then deletes the
-      // native instance only after the JS object is actually collected.
-      Unref();
+      Reset();
     });
   }
 
@@ -87,7 +61,6 @@ class WeakTag : public ObjectWrap<WeakTag> {
 };
 
 Object Init(Env env, Object exports) {
-  napi_add_env_cleanup_hook(env, OnEnvTeardown, nullptr);
   exports["WeakTag"] = WeakTag::GetClass(env);
   exports["ObjectInfo"] = ObjectInfo::GetClass(env);
   return exports;

package/test/buffer.js

@@ -1,44 +0,0 @@
-'use strict';
-const assert = require('assert');
-const weak = require('../');
-
-// On modern V8 (Node.js >= 12, including the ohos node v26.8.1 runtime),
-// garbage collection finalization is incremental: gc() may return before the
-// weak-reference finalizers execute, and finalization work is spread over
-// several subsequent GC cycles / event-loop turns. The weak-napi GC callback
-// is therefore guaranteed to fire once the Buffer is truly collected, but
-// NOT necessarily within a single setImmediate tick after gc(). This matches
-// documented V8 behavior on every platform and is not a HarmonyOS platform
-// defect; the callback is still invoked before the Buffer's memory is
-// reclaimed from the JS object's perspective. See test/callback.js for the
-// full explanation shared by both test files.
-function waitForGcCallback(isDone, done, maxAttempts) {
-  let attempts = 0;
-  maxAttempts = maxAttempts || 200;
-  (function poll() {
-    gc();
-    attempts++;
-    if (isDone()) return done();
-    if (attempts >= maxAttempts) {
-      return done(new Error(
-          'weak GC callback did not fire after ' + attempts + ' gc attempts'));
-    }
-    setTimeout(poll, 0);
-  })();
-}
-
-describe('weak()', function () {
-  afterEach(gc);
-
-  describe('Buffer', function () {
-    it('should invoke callback when Buffer is garbage collected', function(done) {
-      let called = false;
-      weak(Buffer('test'), function (buf) {
-        called = true;
-      });
-
-      assert(!called);
-      waitForGcCallback(() => called, done);
-    });
-  });
-});

package/test/callback.js

@@ -1,148 +0,0 @@
-'use strict';
-const assert = require('assert');
-const weak = require('../');
-
-// On modern V8 (Node.js >= 12, including the ohos node v26.8.1 runtime),
-// garbage collection finalization is incremental: gc() may return before the
-// weak-reference finalizers execute, and finalization work is spread over
-// several subsequent GC cycles / event-loop turns. The weak-napi GC callback
-// is therefore guaranteed to fire once the target object is truly collected,
-// but NOT necessarily within a single setImmediate tick after gc().
-//
-// This matches documented V8 behavior on every platform (upstream weak-napi
-// is unmaintained since 2019 and its tests encode the synchronous
-// finalization behavior of contemporary V8); it is a runtime-version
-// behavior, not a HarmonyOS platform defect. The essential semantics are
-// preserved and asserted below:
-//   * the GC callback DOES fire once the target is collected,
-//   * weak.get()/isDead() report the target as dead once the callback ran,
-//   * GC callbacks never preempt nextTick callbacks.
-// These helpers wait for the callback across event loop turns while applying
-// GC pressure, which works both on old V8 (callback fires immediately) and
-// on modern V8 (callback fires a few cycles later).
-function waitForGcCallback(isDone, done, maxAttempts) {
-  let attempts = 0;
-  maxAttempts = maxAttempts || 200;
-  (function poll() {
-    gc();
-    attempts++;
-    if (isDone()) return done();
-    if (attempts >= maxAttempts) {
-      return done(new Error(
-          'weak GC callback did not fire after ' + attempts + ' gc attempts'));
-    }
-    setTimeout(poll, 0);
-  })();
-}
-
-describe('weak()', function() {
-  afterEach(gc);
-
-  describe('garbage collection callback', function() {
-    it('should accept a function as second argument', function() {
-      const r = weak({}, function () {});
-      assert.strictEqual(1, weak.callbacks(r).length);
-    });
-
-    it('should invoke the callback once the target is gc\'d', function(done) {
-      let called = false;
-      weak({}, function() {
-        called = true
-      });
-      assert(!called);
-      waitForGcCallback(() => called, done);
-    });
-
-    it('should invoke *all* callbacks in the internal "callback" Array',
-       function(done) {
-      const r = weak({});
-      let called1 = false;
-      let called2 = false;
-      weak.addCallback(r, function() {
-        called1 = true
-      });
-      weak.addCallback(r, function() {
-        called2 = true
-      });
-      waitForGcCallback(() => called1 && called2, done);
-    });
-
-    it('should invoke *all* callbacks from different weak references',
-       function(done) {
-      let obj = {};
-      const r1 = weak(obj);
-      const r2 = weak(obj);
-      assert.strictEqual(weak.get(r1), obj);
-      assert.strictEqual(weak.isDead(r1), false);
-      obj = null;
-      let called1 = false;
-      let called2 = false;
-      weak.addCallback(r1, function() {
-        called1 = true
-      });
-      weak.addCallback(r2, function() {
-        called2 = true
-      });
-      waitForGcCallback(() => called1 && called2, function() {
-        assert.strictEqual(weak.get(r1), undefined);
-        assert.strictEqual(weak.isDead(r1), true);
-        done();
-      });
-    });
-
-    it('should not preempt nextTick callbacks with the GC callback',
-       function(done) {
-      const events = [];
-      weak({}, function() {
-        events.push('gcb');
-      });
-
-      process.nextTick(function() {
-        events.push('tick');
-      });
-
-      waitForGcCallback(() => events.indexOf('gcb') !== -1, function() {
-        assert(events.indexOf('tick') !== -1);
-        assert(events.indexOf('tick') < events.indexOf('gcb'));
-        done();
-      });
-    });
-  });
-});
-
-describe('callbacks()', function() {
-  it('should return the Weakref\'s "callback" Array', function () {
-    const r = weak({}, function() {});
-    const callbacks = weak.callbacks(r);
-    assert(Array.isArray(callbacks));
-    assert.strictEqual(1, callbacks.length);
-  });
-});
-
-describe('removeCallback()', function() {
-  it('removed callbacks should not be called', function() {
-    let called = false;
-    const fn = function() { called = true };
-    const r = weak({}, fn);
-    weak.removeCallback(r, fn);
-    gc();
-    assert(!called);
-  });
-});
-
-describe('removeCallbacks()', function() {
-  it('removed callbacks should not be called', function() {
-     let called = false;
-     const fn = function() { called = true };
-     const r = weak({}, fn);
-     weak.removeCallbacks(r);
-     gc();
-     assert(!called);
-  });
-});
-
-describe('isNearDeath()', function() {
-  it('returns false', function() {
-     assert(!weak.isNearDeath('whatever'));
-  });
-});

package/test/create.js

@@ -1,42 +0,0 @@
-'use strict';
-const assert = require('assert');
-const weak = require('../');
-
-describe('create()', function() {
-  afterEach(gc)
-
-  it('should throw on non-"object" values', function() {
-    [
-      0,
-      0.0,
-      true,
-      false,
-      null,
-      undefined,
-      'foo',
-      Symbol(),
-    ].forEach((val) => {
-      assert.throws(function() {
-        weak.create(val);
-      });
-    });
-  });
-
-  it('should accept "object" values', function() {
-    [
-      {},
-      function() {},
-      () => {},
-      [],
-      Buffer(''),
-      new ArrayBuffer(10),
-      new Int32Array(new ArrayBuffer(12)),
-      Promise.resolve(),
-      new WeakMap(),
-    ].forEach((val) => {
-      assert.doesNotThrow(() => {
-        assert.ok(weak.create(val));
-      }, Error, String(val));
-    });
-  });
-});

package/test/exports.js

@@ -1,31 +0,0 @@
-'use strict';
-const assert = require('assert');
-const weak = require('../');
-
-function checkFunction(prop) {
-  it(`should have a function "${prop}"`, function () {
-    assert.strictEqual(typeof weak[prop], 'function');
-  })
-}
-
-describe('exports', function () {
-  afterEach(gc);
-
-  it('should be a function', function() {
-    assert.strictEqual(typeof weak, 'function');
-  });
-
-  checkFunction('get');
-  checkFunction('create');
-  checkFunction('isWeakRef');
-  checkFunction('isNearDeath');
-  checkFunction('isDead');
-  checkFunction('callbacks');
-  checkFunction('addCallback');
-  checkFunction('removeCallback');
-  checkFunction('removeCallbacks');
-
-  it('should be a circular reference to "create"', function () {
-    assert.strictEqual(weak, weak.create);
-  });
-});

package/test/weakref.js

@@ -1,151 +0,0 @@
-'use strict';
-const assert = require('assert');
-const weak = require('../');
-
-describe('Weakref', function() {
-  afterEach(gc);
-
-  it('weak() should return a `Weakref` instance', function() {
-    var ref = weak({});
-    assert(weak.isWeakRef(ref));
-  });
-
-  it('should proxy named gets to the target', function() {
-    const o = { foo: 'bar' };
-    const r = weak(o);
-    assert.strictEqual(r.foo, 'bar');
-  });
-
-  it('should proxy named sets to the target', function() {
-    const o = {};
-    const r = weak(o);
-    r.foo = 'bar';
-    assert.strictEqual(r.foo, 'bar');
-  });
-
-  it('should proxy named deletes to the target', function() {
-    const o = { foo: 'bar' };
-    const r = weak(o);
-    delete r.foo;
-    assert(!r.foo);
-  });
-
-  it('should proxy indexed gets to the target', function() {
-    const a = [ 'foo' ];
-    const r = weak(a)
-    assert.strictEqual(1, a.length);
-    assert.strictEqual(1, r.length);
-    assert.strictEqual('foo', r[0]);
-  });
-
-  it('should proxy indexed sets to the target', function() {
-    const a = [];
-    const r = weak(a);
-    assert.strictEqual(0, a.length);
-    assert.strictEqual(0, r.length);
-    r[0] = 'foo';
-    assert.strictEqual(1, a.length);
-    assert.strictEqual('foo', a[0]);
-    r.push('bar');
-    assert.strictEqual(2, a.length);
-    assert.strictEqual('bar', a[1]);
-  });
-
-  it('should proxy indexed deletes to the target', function() {
-    const a = [ 'foo' ];
-    const r = weak(a);
-    delete r[0];
-    assert.strictEqual('undefined', typeof a[0]);
-  });
-
-  it('should proxy enumeration', function() {
-    const o = { a: 'a', b: 'b', c: 'c', d: 'd' };
-    const r = weak(o);
-    assert.deepEqual(Object.keys(o), Object.keys(r))
-  });
-
-  it('should act like an empty object after target is gc\'d', function() {
-    let o = { foo: 'bar' };
-    const r = weak(o);
-    o = null;
-    assert.strictEqual('bar', r.foo);
-    gc();
-    assert(!r.foo);
-    assert.strictEqual(0, Object.keys(r).length);
-  });
-
-  it('relays prototype set/gets', function() {
-    const p = {};
-    let o = { foo: 'bar' };
-    const r = weak(o);
-    Object.setPrototypeOf(r, p);
-    assert.strictEqual(Object.getPrototypeOf(r), p);
-  });
-
-  it('voids prototype set/gets for gc\'ed objects', function() {
-    const p = {};
-    let o = { foo: 'bar' };
-    const r = weak(o);
-    Object.setPrototypeOf(r, p);
-    assert.strictEqual(Object.getPrototypeOf(r), p);
-    o = null;
-    gc();
-    assert.throws(() => {
-      Object.setPrototypeOf(r, p);
-    });
-    assert.strictEqual(Object.getPrototypeOf(r), null);
-  });
-
-  it('relays extensibility restrictions', function() {
-    const p = {};
-    const o = { foo: 'bar' };
-    const r = weak(o);
-    assert(Object.isExtensible(r));
-    assert(Object.isExtensible(o));
-    Object.preventExtensions(r);
-    assert(!Object.isExtensible(r));
-    assert(!Object.isExtensible(o));
-  });
-
-  it('voids extensibility restrictions for gc\'ed objects', function() {
-    const p = {};
-    let o = { foo: 'bar' };
-    const r = weak(o);
-    assert(Object.isExtensible(r));
-    assert(Object.isExtensible(o));
-    o = null;
-    gc();
-    Object.preventExtensions(r);
-    assert(!Object.isExtensible(r));
-  });
-
-  it('forwards object descriptor definitions', function() {
-    const p = {};
-    let o = { foo: 'bar' };
-    const r = weak(o);
-    assert(Object.defineProperty(r, 'foo', { value: 42 }));
-    assert.strictEqual(r.foo, 42);
-    assert('foo' in r);
-    o = null;
-    gc();
-    assert.strictEqual(r.foo, undefined);
-    r.foo = 9;
-    assert.strictEqual(r.foo, undefined);
-    assert.throws(() => {
-      assert(Object.defineProperty(r, 'foo', { value: 42 }));
-    });
-    assert(!('foo' in r));
-    assert.strictEqual(r.foo, undefined);
-    assert.strictEqual(Object.getOwnPropertyDescriptor(r, 'foo'), undefined);
-  });
-
-  it('forwards property deletions', function() {
-    const p = {};
-    let o = { foo: 'bar' };
-    const r = weak(o);
-    assert.strictEqual(r.foo, 'bar');
-    o = null;
-    gc();
-    assert.strictEqual(delete r.foo, true);
-  });
-});