From f08f756fc06932ff13b2fbf026faa1276e30ed50 Mon Sep 17 00:00:00 2001
From: uzlopak <aras.abbasi@googlemail.com>
Date: Wed, 18 Oct 2023 03:47:25 +0200
Subject: [PATCH] lib: add navigator.onLine

---
 doc/api/globals.md              | 26 ++++++++++++++++++++++++++
 lib/internal/navigator.js       |  9 +++++++++
 src/node_os.cc                  | 28 ++++++++++++++++++++++++++++
 test/parallel/test-navigator.js |  2 ++
 typings/internalBinding/os.d.ts |  1 +
 5 files changed, 66 insertions(+)

diff --git a/doc/api/globals.md b/doc/api/globals.md
index 0ca27111db49e1..ba617830b5c8a9 100644
--- a/doc/api/globals.md
+++ b/doc/api/globals.md
@@ -629,6 +629,32 @@ logical processors available to the current Node.js instance.
 console.log(`This process is running on ${navigator.hardwareConcurrency}`);
 ```
 
+### `navigator.onLine`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {boolean}
+
+The [`navigator.onLine`](https://html.spec.whatwg.org/multipage/system-state.html#dom-navigator-online-dev)
+read-only property returns the online status available
+of the current Node.js instance. If the Node.js instance is not able to detect
+to a local area network (LAN) or a router, it is offline; all other conditions
+return true. So while you can assume that the Node.js instance is offline when
+it returns a false value, you cannot assume that a true value necessarily
+means that the Node.js instance can access the internet. You could be getting
+false positives, such as in cases where the computer is running a
+virtualization software that has virtual ethernet adapters that are always
+"connected."
+
+Therefore, if you really want to determine the online status of the Node.js
+instance, you should develop additional means for checking.
+
+```js
+console.log(`This process is ${navigator.onLine ? 'online' : 'offline'}`);
+```
+
 ## `PerformanceEntry`
 
 <!-- YAML
diff --git a/lib/internal/navigator.js b/lib/internal/navigator.js
index 5971891ea73cc9..2dbbcb8be156ee 100644
--- a/lib/internal/navigator.js
+++ b/lib/internal/navigator.js
@@ -15,6 +15,7 @@ const {
 
 const {
   getAvailableParallelism,
+  getOnLineStatus,
 } = internalBinding('os');
 
 const kInitialize = Symbol('kInitialize');
@@ -37,10 +38,18 @@ class Navigator {
     this.#availableParallelism ??= getAvailableParallelism();
     return this.#availableParallelism;
   }
+
+  /**
+   * @return {boolean}
+   */
+  get onLine() {
+    return getOnLineStatus();
+  }
 }
 
 ObjectDefineProperties(Navigator.prototype, {
   hardwareConcurrency: kEnumerableProperty,
+  onLine: kEnumerableProperty,
 });
 
 module.exports = {
diff --git a/src/node_os.cc b/src/node_os.cc
index 7318c1a368d871..db64192f5d0156 100644
--- a/src/node_os.cc
+++ b/src/node_os.cc
@@ -247,6 +247,32 @@ static void GetInterfaceAddresses(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(Array::New(isolate, result.data(), result.size()));
 }
 
+static void GetOnLineStatus(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  uv_interface_address_t* interfaces;
+  int count, i;
+
+  int err = uv_interface_addresses(&interfaces, &count);
+
+  if (err == UV_ENOSYS) return args.GetReturnValue().Set(false);
+
+  if (err) {
+    CHECK_GE(args.Length(), 1);
+    env->CollectUVExceptionInfo(
+        args[args.Length() - 1], errno, "uv_interface_addresses");
+    return args.GetReturnValue().Set(false);
+  }
+
+  for (i = 0; i < count; i++) {
+    if (interfaces[i].is_internal == false) {
+      uv_free_interface_addresses(interfaces, count);
+      return args.GetReturnValue().Set(true);
+    }
+  }
+
+  uv_free_interface_addresses(interfaces, count);
+  return args.GetReturnValue().Set(false);
+}
 
 static void GetHomeDirectory(const FunctionCallbackInfo<Value>& args) {
   Environment* env = Environment::GetCurrent(args);
@@ -403,6 +429,7 @@ void Initialize(Local<Object> target,
   SetMethod(context, target, "getPriority", GetPriority);
   SetMethod(
       context, target, "getAvailableParallelism", GetAvailableParallelism);
+  SetMethod(context, target, "getOnLineStatus", GetOnLineStatus);
   SetMethod(context, target, "getOSInformation", GetOSInformation);
   target
       ->Set(context,
@@ -419,6 +446,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
   registry->Register(GetFreeMemory);
   registry->Register(GetCPUInfo);
   registry->Register(GetInterfaceAddresses);
+  registry->Register(GetOnLineStatus);
   registry->Register(GetHomeDirectory);
   registry->Register(GetUserInfo);
   registry->Register(SetPriority);
diff --git a/test/parallel/test-navigator.js b/test/parallel/test-navigator.js
index 300446f2c5dcdc..5edcd51f2e6800 100644
--- a/test/parallel/test-navigator.js
+++ b/test/parallel/test-navigator.js
@@ -13,3 +13,5 @@ const is = {
 is.number(+navigator.hardwareConcurrency, 'hardwareConcurrency');
 is.number(navigator.hardwareConcurrency, 'hardwareConcurrency');
 assert.ok(navigator.hardwareConcurrency > 0);
+
+assert.strictEqual(typeof navigator.onLine, 'boolean');
diff --git a/typings/internalBinding/os.d.ts b/typings/internalBinding/os.d.ts
index 91e907ef3c1205..f94a2dbb29816b 100644
--- a/typings/internalBinding/os.d.ts
+++ b/typings/internalBinding/os.d.ts
@@ -10,6 +10,7 @@ export interface OSBinding {
   getFreeMem(): number;
   getCPUs(): Array<string | number>;
   getInterfaceAddresses(ctx: InternalOSBinding.OSContext): Array<string | number | boolean> | undefined;
+  getOnLineStatus(): boolean;
   getHomeDirectory(ctx: InternalOSBinding.OSContext): string | undefined;
   getUserInfo(options: { encoding?: string } | undefined, ctx: InternalOSBinding.OSContext): {
     uid: number;