@ohos-ports/bare-signals 5.0.0-beta.0

package/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 4.0)
+
+find_package(cmake-bare REQUIRED PATHS node_modules/cmake-bare)
+
+project(bare_signals C)
+
+add_bare_module(bare_signals)
+
+target_sources(
+  ${bare_signals}
+  PRIVATE
+    binding.c
+)

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,21 @@
+# bare-signals
+
+Native signal handling for JavaScript.
+
+```
+npm i bare-signals
+```
+
+## Usage
+
+```js
+const Signal = require('bare-signals')
+
+const sigint = new Signal('SIGINT')
+
+sigint.on('signal', () => console.log('SIGINT caught')).start()
+```
+
+## License
+
+Apache-2.0

package/binding.c

@@ -0,0 +1,431 @@
+#include <assert.h>
+#include <signal.h>
+#include <uv.h>
+
+#include <node_api.h>
+
+typedef struct {
+  uv_signal_t handle;
+
+  napi_env env;
+  napi_ref ctx;
+  napi_ref on_signal;
+  napi_ref on_close;
+
+  bool closing;
+  bool exiting;
+  bool hook_added;
+} bare_signal_t;
+
+static void
+bare_signals__on_signal(uv_signal_t *handle, int signum) {
+  int err;
+
+  bare_signal_t *signal = (bare_signal_t *) handle;
+
+  if (signal->exiting) return;
+
+  napi_env env = signal->env;
+
+  napi_handle_scope scope;
+  err = napi_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  napi_value on_signal;
+  err = napi_get_reference_value(env, signal->on_signal, &on_signal);
+  assert(err == 0);
+
+  napi_value ctx;
+  err = napi_get_reference_value(env, signal->ctx, &ctx);
+  assert(err == 0);
+
+  err = napi_make_callback(env, NULL, ctx, on_signal, 0, NULL, NULL);
+  assert(err == 0);
+
+  err = napi_close_handle_scope(env, scope);
+  assert(err == 0);
+}
+
+static void
+bare_signals__on_close(uv_handle_t *handle) {
+  int err;
+
+  bare_signal_t *signal = (bare_signal_t *) handle;
+
+  napi_env env = signal->env;
+
+  napi_handle_scope scope;
+  err = napi_open_handle_scope(env, &scope);
+  assert(err == 0);
+
+  napi_value on_close;
+  err = napi_get_reference_value(env, signal->on_close, &on_close);
+  assert(err == 0);
+
+  napi_value ctx;
+  err = napi_get_reference_value(env, signal->ctx, &ctx);
+  assert(err == 0);
+
+  err = napi_delete_reference(env, signal->on_signal);
+  assert(err == 0);
+
+  err = napi_delete_reference(env, signal->on_close);
+  assert(err == 0);
+
+  err = napi_delete_reference(env, signal->ctx);
+  assert(err == 0);
+
+  if (!signal->exiting) {
+    err = napi_make_callback(env, NULL, ctx, on_close, 0, NULL, NULL);
+    assert(err == 0);
+  }
+
+  err = napi_close_handle_scope(env, scope);
+  assert(err == 0);
+}
+
+// Node N-API equivalent of the Bare deferred teardown callback: close the
+// uv_signal handle when the environment is being torn down.
+static void
+bare_signals__on_teardown(void *data) {
+  bare_signal_t *signal = (bare_signal_t *) data;
+
+  signal->exiting = true;
+
+  if (signal->closing) return;
+
+  uv_close((uv_handle_t *) &signal->handle, bare_signals__on_close);
+}
+
+static napi_value
+bare_signals_init(napi_env env, napi_callback_info info) {
+  int err;
+
+  size_t argc = 3;
+  napi_value argv[3];
+
+  err = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 3);
+
+  napi_value handle;
+
+  bare_signal_t *signal;
+  err = napi_create_arraybuffer(env, sizeof(bare_signal_t), (void **) &signal, &handle);
+  if (err < 0) return NULL;
+
+  uv_loop_t *loop;
+  err = napi_get_uv_event_loop(env, &loop);
+  assert(err == 0);
+
+  err = uv_signal_init(loop, &signal->handle);
+
+  if (err < 0) {
+    napi_throw_error(env, uv_err_name(err), uv_strerror(err));
+    return NULL;
+  }
+
+  signal->env = env;
+  signal->closing = false;
+  signal->exiting = false;
+  signal->hook_added = false;
+
+  err = napi_create_reference(env, argv[0], 1, &signal->ctx);
+  assert(err == 0);
+
+  err = napi_create_reference(env, argv[1], 1, &signal->on_signal);
+  assert(err == 0);
+
+  err = napi_create_reference(env, argv[2], 1, &signal->on_close);
+  assert(err == 0);
+
+  err = napi_add_env_cleanup_hook(env, bare_signals__on_teardown, (void *) signal);
+  assert(err == 0);
+
+  signal->hook_added = true;
+
+  return handle;
+}
+
+static napi_value
+bare_signals_close(napi_env env, napi_callback_info info) {
+  int err;
+
+  size_t argc = 1;
+  napi_value argv[1];
+
+  err = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  bare_signal_t *signal;
+  err = napi_get_arraybuffer_info(env, argv[0], (void **) &signal, NULL);
+  assert(err == 0);
+
+  signal->closing = true;
+
+  if (signal->hook_added) {
+    err = napi_remove_env_cleanup_hook(env, bare_signals__on_teardown, (void *) signal);
+    assert(err == 0);
+    signal->hook_added = false;
+  }
+
+  uv_close((uv_handle_t *) &signal->handle, bare_signals__on_close);
+
+  return NULL;
+}
+
+static napi_value
+bare_signals_start(napi_env env, napi_callback_info info) {
+  int err;
+
+  size_t argc = 2;
+  napi_value argv[2];
+
+  err = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 2);
+
+  bare_signal_t *signal;
+  err = napi_get_arraybuffer_info(env, argv[0], (void **) &signal, NULL);
+  assert(err == 0);
+
+  int32_t signum;
+  err = napi_get_value_int32(env, argv[1], &signum);
+  assert(err == 0);
+
+  err = uv_signal_start(&signal->handle, bare_signals__on_signal, signum);
+
+  if (err < 0) {
+    napi_throw_error(env, uv_err_name(err), uv_strerror(err));
+    return NULL;
+  }
+
+  return NULL;
+}
+
+static napi_value
+bare_signals_stop(napi_env env, napi_callback_info info) {
+  int err;
+
+  size_t argc = 1;
+  napi_value argv[1];
+
+  err = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  bare_signal_t *signal;
+  err = napi_get_arraybuffer_info(env, argv[0], (void **) &signal, NULL);
+  assert(err == 0);
+
+  err = uv_signal_stop(&signal->handle);
+
+  if (err < 0) {
+    napi_throw_error(env, uv_err_name(err), uv_strerror(err));
+    return NULL;
+  }
+
+  return NULL;
+}
+
+static napi_value
+bare_signals_ref(napi_env env, napi_callback_info info) {
+  int err;
+
+  size_t argc = 1;
+  napi_value argv[1];
+
+  err = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  bare_signal_t *signal;
+  err = napi_get_arraybuffer_info(env, argv[0], (void **) &signal, NULL);
+  assert(err == 0);
+
+  uv_ref((uv_handle_t *) &signal->handle);
+
+  return NULL;
+}
+
+static napi_value
+bare_signals_unref(napi_env env, napi_callback_info info) {
+  int err;
+
+  size_t argc = 1;
+  napi_value argv[1];
+
+  err = napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  assert(err == 0);
+
+  assert(argc == 1);
+
+  bare_signal_t *signal;
+  err = napi_get_arraybuffer_info(env, argv[0], (void **) &signal, NULL);
+  assert(err == 0);
+
+  uv_unref((uv_handle_t *) &signal->handle);
+
+  return NULL;
+}
+
+static napi_value
+bare_signals_exports(napi_env env, napi_value exports) {
+  int err;
+
+#define V(name, fn) \
+  { \
+    napi_value val; \
+    err = napi_create_function(env, name, NAPI_AUTO_LENGTH, fn, NULL, &val); \
+    assert(err == 0); \
+    err = napi_set_named_property(env, exports, name, val); \
+    assert(err == 0); \
+  }
+
+  V("init", bare_signals_init)
+  V("close", bare_signals_close)
+  V("start", bare_signals_start)
+  V("stop", bare_signals_stop)
+  V("ref", bare_signals_ref)
+  V("unref", bare_signals_unref)
+#undef V
+
+  napi_value signals;
+  err = napi_create_object(env, &signals);
+  assert(err == 0);
+
+  err = napi_set_named_property(env, exports, "signals", signals);
+  assert(err == 0);
+
+#define V(name) \
+  { \
+    napi_value val; \
+    err = napi_create_uint32(env, name, &val); \
+    assert(err == 0); \
+    err = napi_set_named_property(env, signals, #name, val); \
+    assert(err == 0); \
+  }
+
+#ifdef SIGHUP
+  V(SIGHUP);
+#endif
+#ifdef SIGINT
+  V(SIGINT);
+#endif
+#ifdef SIGQUIT
+  V(SIGQUIT);
+#endif
+#ifdef SIGILL
+  V(SIGILL);
+#endif
+#ifdef SIGTRAP
+  V(SIGTRAP);
+#endif
+#ifdef SIGABRT
+  V(SIGABRT);
+#endif
+#ifdef SIGIOT
+  V(SIGIOT);
+#endif
+#ifdef SIGBUS
+  V(SIGBUS);
+#endif
+#ifdef SIGFPE
+  V(SIGFPE);
+#endif
+#ifdef SIGKILL
+  V(SIGKILL);
+#endif
+#ifdef SIGUSR1
+  V(SIGUSR1);
+#endif
+#ifdef SIGSEGV
+  V(SIGSEGV);
+#endif
+#ifdef SIGUSR2
+  V(SIGUSR2);
+#endif
+#ifdef SIGPIPE
+  V(SIGPIPE);
+#endif
+#ifdef SIGALRM
+  V(SIGALRM);
+#endif
+#ifdef SIGTERM
+  V(SIGTERM);
+#endif
+#ifdef SIGCHLD
+  V(SIGCHLD);
+#endif
+#ifdef SIGSTKFLT
+  V(SIGSTKFLT);
+#endif
+#ifdef SIGCONT
+  V(SIGCONT);
+#endif
+#ifdef SIGSTOP
+  V(SIGSTOP);
+#endif
+#ifdef SIGTSTP
+  V(SIGTSTP);
+#endif
+#ifdef SIGBREAK
+  V(SIGBREAK);
+#endif
+#ifdef SIGTTIN
+  V(SIGTTIN);
+#endif
+#ifdef SIGTTOU
+  V(SIGTTOU);
+#endif
+#ifdef SIGURG
+  V(SIGURG);
+#endif
+#ifdef SIGXCPU
+  V(SIGXCPU);
+#endif
+#ifdef SIGXFSZ
+  V(SIGXFSZ);
+#endif
+#ifdef SIGVTALRM
+  V(SIGVTALRM);
+#endif
+#ifdef SIGPROF
+  V(SIGPROF);
+#endif
+#ifdef SIGWINCH
+  V(SIGWINCH);
+#endif
+#ifdef SIGIO
+  V(SIGIO);
+#endif
+#ifdef SIGPOLL
+  V(SIGPOLL);
+#endif
+#ifdef SIGLOST
+  V(SIGLOST);
+#endif
+#ifdef SIGPWR
+  V(SIGPWR);
+#endif
+#ifdef SIGINFO
+  V(SIGINFO);
+#endif
+#ifdef SIGSYS
+  V(SIGSYS);
+#endif
+#ifdef SIGUNUSED
+  V(SIGUNUSED);
+#endif
+#undef V
+
+  return exports;
+}
+
+NAPI_MODULE(bare_signals, bare_signals_exports)

package/binding.js

@@ -0,0 +1,7 @@
+// Load the native addon. Under the Bare runtime `require.addon()` resolves
+// the cmake-bare addon; under Node.js fall back to the node-gyp built addon.
+if (typeof require.addon === 'function') {
+  module.exports = require.addon()
+} else {
+  module.exports = require('./build/Release/bare_signals.node')
+}

package/index.d.ts

@@ -0,0 +1,32 @@
+import EventEmitter from 'bare-events'
+
+interface SignalEmitter extends EventEmitter<{ [signal: string]: [string, number] }> {
+  ref(): this
+  unref(): this
+}
+
+declare class SignalEmitter {}
+
+declare class SignalError extends Error {
+  readonly code: string
+}
+
+interface Signal extends EventEmitter<{ close: []; signal: [signum: number] }> {
+  start(): this
+  stop(): this
+  ref(): this
+  unref(): this
+  close(): Promise<void>
+}
+
+declare class Signal {
+  constructor(signum: number | string)
+}
+
+declare namespace Signal {
+  export { SignalEmitter as Emitter, SignalError as errors }
+
+  export const constants: Record<string, number>
+}
+
+export = Signal

package/index.js

@@ -0,0 +1,71 @@
+const EventEmitter = require('bare-events')
+const binding = require('./binding')
+const errors = require('./lib/errors')
+
+const signals = binding.signals
+
+module.exports = exports = class Signal extends EventEmitter {
+  constructor(signum) {
+    super()
+
+    if (typeof signum === 'string') {
+      if (signum in signals === false) {
+        throw errors.UNKNOWN_SIGNAL(`Unknown signal '${signum}'`)
+      }
+
+      signum = signals[signum]
+    }
+
+    this._signum = signum
+    this._closing = null
+    this._handle = binding.init(this, this._onsignal, this._onclose)
+  }
+
+  start() {
+    if (this._closing) throw errors.SIGNAL_CLOSED('Signal is closed')
+    binding.start(this._handle, this._signum)
+    return this
+  }
+
+  stop() {
+    if (this._closing) return this
+    binding.stop(this._handle)
+    return this
+  }
+
+  ref() {
+    if (this._closing) return this
+    binding.ref(this._handle)
+    return this
+  }
+
+  unref() {
+    if (this._closing) return this
+    binding.unref(this._handle)
+    return this
+  }
+
+  close() {
+    if (this._closing) return this._closing
+    this._closing = EventEmitter.once(this, 'close')
+
+    binding.close(this._handle)
+
+    return this._closing
+  }
+
+  _onsignal() {
+    this.emit('signal', this._signum)
+  }
+
+  _onclose() {
+    this._handle = null
+
+    this.emit('close')
+  }
+}
+
+exports.Emitter = require('./lib/emitter')
+
+exports.constants = signals
+exports.errors = errors

package/lib/emitter.js

@@ -0,0 +1,57 @@
+const EventEmitter = require('bare-events')
+const Signal = require('..')
+
+module.exports = class SignalEmitter extends EventEmitter {
+  constructor() {
+    super()
+
+    this._signals = new Map()
+    this._unrefed = false
+
+    this.on('newListener', this._onnewlistener).on('removeListener', this._onremovelistener)
+  }
+
+  ref() {
+    this._unrefed = false
+    for (const signal of this._signals.values()) signal.ref()
+    return this
+  }
+
+  unref() {
+    this._unrefed = true
+    for (const signal of this._signals.values()) signal.unref()
+    return this
+  }
+
+  _onnewlistener(name) {
+    if (name === 'newListener' || name === 'removeListener') return
+
+    if (this.listenerCount(name) === 0) {
+      const signal = new Signal(name)
+
+      signal.on('signal', this._onsignal.bind(this, name)).start()
+
+      if (this._unrefed) signal.unref()
+
+      this._signals.set(name, signal)
+    }
+  }
+
+  _onremovelistener(name) {
+    if (name === 'newListener' || name === 'removeListener') return
+
+    if (this.listenerCount(name) === 0) {
+      const signal = this._signals.get(name)
+
+      if (this._unrefed) signal.ref()
+
+      signal.close()
+
+      this._signals.delete(name)
+    }
+  }
+
+  _onsignal(name) {
+    this.emit(name, name, Signal.constants[name])
+  }
+}

package/lib/errors.js

@@ -0,0 +1,22 @@
+module.exports = class SignalError extends Error {
+  constructor(msg, fn = SignalError, code = fn.name) {
+    super(`${code}: ${msg}`)
+    this.code = code
+
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, fn)
+    }
+  }
+
+  get name() {
+    return 'SignalError'
+  }
+
+  static UNKNOWN_SIGNAL(msg) {
+    return new SignalError(msg, SignalError.UNKNOWN_SIGNAL)
+  }
+
+  static SIGNAL_CLOSED(msg) {
+    return new SignalError(msg, SignalError.SIGNAL_CLOSED)
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@ohos-ports/bare-signals",
+  "version": "5.0.0-beta.0",
+  "description": "Native signal handling for JavaScript",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package": "./package.json",
+    "./errors": "./lib/errors.js",
+    "./emitter": "./lib/emitter.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "binding.c",
+    "binding.js",
+    "CMakeLists.txt",
+    "lib",
+    "build/Release/*.node"
+  ],
+  "addon": true,
+  "scripts": {
+    "format": "prettier --write . && lunte --fix",
+    "lint": "prettier --check . && lunte",
+    "test": "brittle-bare --coverage test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/bare-signals/5.0.0"
+  },
+  "author": "Holepunch",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues"
+  },
+  "homepage": "https://github.com/holepunchto/bare-signals#readme",
+  "engines": {
+    "bare": ">=1.7.0"
+  },
+  "dependencies": {
+    "bare-events": "^2.5.3"
+  },
+  "devDependencies": {
+    "@ohos-ports/bare-os": "^3.9.3-beta.0",
+    "brittle": "^3.2.1",
+    "cmake-bare": "^1.1.6",
+    "lunte": "^1.8.3",
+    "prettier": "^3.4.1",
+    "prettier-config-holepunch": "^2.0.0"
+  }
+}