node-gtk 3.0.0 → 4.0.1

package/README.md

@@ -22,7 +22,7 @@
 
 `node-gtk` lets you build native GTK apps on **linux**, **macOS** and  **windows**
 with full **ESM**, **TypeScript** and **CSS hot-reload** support. Prebuilt binaries 
-are available for Node.js versions **20**, **22** and **24**.
+are available for Node.js versions **22**, **24** and **26**.
 
 <p align="center">
   <img src="./img/browser.png" style="max-width: 500px; height: auto;" alt="A web browser build with node-gtk" />

package/binding.gyp

@@ -1,4 +1,24 @@
 {
+    # Node 26's official Windows binary is built with ClangCL + ThinLTO, so its
+    # common.gypi injects `-flto=thin` and `/opt:lldltojobs=N` into the MSVC
+    # AdditionalOptions of every target. MSVC's link.exe rejects those
+    # Clang/lld-only options (LNK1117), which breaks the build on Windows +
+    # Node 26. Strip them with gyp's list-exclusion filter. This lives under
+    # msvs_settings, so it is inert on the make/xcode generators (Linux/macOS).
+    "target_defaults": {
+        "configurations": {
+            "Release": {
+                "msvs_settings": {
+                    "VCCLCompilerTool": {
+                        "AdditionalOptions/": [ ["exclude", "flto"] ]
+                    },
+                    "VCLinkerTool": {
+                        "AdditionalOptions/": [ ["exclude", "flto"], ["exclude", "lldltojobs"] ]
+                    }
+                }
+            }
+        }
+    },
     "targets": [
         {
             "target_name": "node_gtk",
@@ -11,6 +31,7 @@
                 "src/debug.cc",
                 "src/error.cc",
                 "src/function.cc",
+                "src/fundamental.cc",
                 "src/gi.cc",
                 "src/gobject.cc",
                 "src/loop.cc",

package/lib/bootstrap.js

@@ -292,23 +292,55 @@ function makeObject(info) {
    */
 
   forLoopFn(info, GI.object_info_get_n_interfaces, GI.object_info_get_interface, (interfaceInfo) => {
-    const interface_ = getInterface(interfaceInfo)
-
-    interface_._properties.forEach(description => {
-      define(constructor, description)
-    })
-    interface_._methods.forEach(description => {
-      define(constructor, description)
-    })
-    interface_._constants.forEach(description => {
-      define(constructor, description)
-    })
+    applyInterface(constructor, getInterface(interfaceInfo))
   })
 
 
   return constructor;
 }
 
+/*
+ * Mix an interface's properties/methods/constants (as prepared by
+ * makeInterface) into a class constructor. Shared by makeObject() and the
+ * `applyInterfaceMethods` callback below.
+ */
+function applyInterface(constructor, interface_) {
+  interface_._properties.forEach(description => define(constructor, description))
+  interface_._methods.forEach(description => define(constructor, description))
+  interface_._constants.forEach(description => define(constructor, description))
+}
+
+/*
+ * Called from C++ (GetClassTemplate) the first time a private/non-introspectable
+ * concrete type is wrapped, to install the methods of the interfaces it
+ * implements onto its prototype. makeObject() never runs for such types, so
+ * without this their instances would only expose the base GObject methods
+ * (issue #441). `interfaceRefs` is an array of { namespace, name }.
+ */
+function applyInterfaceMethods(constructor, interfaceRefs) {
+  const repo = GI.Repository_get_default()
+
+  interfaceRefs.forEach(({ namespace, name }) => {
+    const cache = moduleCache[namespace]
+    // The interface's module must be loaded for its constructor to exist; if it
+    // isn't, there is nothing meaningful to install.
+    if (!cache)
+      return
+
+    let interface_ = cache[name]
+    if (!interface_) {
+      const info = GI.Repository_find_by_name.call(repo, namespace, name)
+      if (!info)
+        return
+      interface_ = getInterface(info)
+    }
+
+    applyInterface(constructor, interface_)
+  })
+}
+
+internal.SetInterfaceMethodsApplier(applyInterfaceMethods)
+
 function makeBoxed(info) {
   if (getType(info) == GI.InfoType.UNION) {
     return makeUnion(info)

package/lib/loop.js

@@ -45,10 +45,22 @@ function start() {
  * macrotask lets the module's top-level microtask return first, so the queue
  * drains and the loop integration takes over from a clean (non-nested) state.
  *
+ * We defer with setTimeout, NOT setImmediate. A setImmediate callback runs
+ * *inside* Node's immediate-processing machinery (native CheckImmediate ->
+ * processImmediate). Because `run` never returns (it blocks in the GLib main
+ * loop until the app quits), CheckImmediate never reaches the code that stops
+ * Node's private immediate uv_idle handle, so that handle stays active forever.
+ * An active idle handle pins uv_backend_timeout() at 0, which makes the nested
+ * uv-in-GLib loop busy-spin at 100% CPU (worse on Node 26 / libuv 1.52, where
+ * the immediate's wakeup eventfd also stays signalled). A one-shot timer is
+ * removed from libuv's timer heap before its callback runs, so blocking inside
+ * it leaves no libuv state active and the loop can sleep normally. See #477.
+ *
  * Under CommonJS (and inside signal callbacks) we are not in a microtask, so we
  * run synchronously and preserve the original blocking semantics exactly.
  *
  * https://github.com/romgrk/node-gtk/issues/442
+ * https://github.com/romgrk/node-gtk/issues/477
  *
  * Returns the native call's result when run synchronously (so e.g.
  * `const status = app.run()` keeps working under CommonJS); returns undefined
@@ -64,7 +76,7 @@ function runLoopEntry(run) {
   start()
 
   if (internal.IsRunningMicrotasks()) {
-    setImmediate(run)
+    setTimeout(run, 0)
     return undefined
   }
   return run()

package/lib/overrides/Gtk-4.0.js

@@ -2,10 +2,6 @@
  * Gtk-4.0.js
  */
 
-const internal = require('../native.js')
-const Module = require('../module')
-const Gio = Module.require('Gio')
-
 exports.apply = (Gtk) => {
 
   Gtk.EVENT_CONTINUE = false
@@ -104,29 +100,12 @@ exports.apply = (Gtk) => {
     return tickId
   }
 
-  const originalGetFile = Gtk.FileChooser.prototype.getFile
-
-  /**
-   * Gtk.FileChooserDialog.prototype.getFile
-   * @returns {GFile} - The file
-   */
-  Gtk.FileChooserDialog.prototype.getFile = function getFile() {
-    const file = originalGetFile.call(this)
-    if (file)
-      file.__proto__= Gio.File.prototype
-    return file
-  }
-
-  /**
-   * Gtk.FileChooserWidget.prototype.getFile
-   * @returns {GFile} - The file
-   */
-  Gtk.FileChooserWidget.prototype.getFile = function getFile() {
-    const file = originalGetFile.call(this)
-    if (file)
-      file.__proto__= Gio.File.prototype
-    return file
-  }
+  /* getFile() used to need a manual `file.__proto__ = Gio.File.prototype` fixup
+   * because the returned GLocalFile is a private type whose GFile interface
+   * methods weren't mixed into its prototype. That is now handled generically
+   * for every private type at wrap time (see issue #441), so the override is no
+   * longer necessary — the introspected getFile() returns a fully-usable file
+   * (or null when nothing is selected). */
 }
 
 function easeOutCubic(t) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-gtk",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "description": "GNOME Gtk+ bindings for NodeJS",
   "main": "lib/index.js",
   "exports": {
@@ -64,7 +64,6 @@
     "assert": "^1.5.0",
     "aws-sdk": "^2.452.0",
     "chalk": "^2.4.2",
-    "deasync": "^0.1.30",
     "mocha": "^7.1.0",
     "nid-parser": "0.0.5",
     "node-pre-gyp-github": "^1.4.5"

package/src/boxed.cc

@@ -6,6 +6,7 @@
 #include "debug.h"
 #include "error.h"
 #include "function.h"
+#include "fundamental.h"
 #include "gi.h"
 #include "gobject.h"
 #include "macros.h"
@@ -258,8 +259,8 @@ static void BoxedConstructor(const Nan::FunctionCallbackInfo<Value> &info) {
     box->persistent = new Nan::Persistent<Object>(self);
     box->persistent->SetWeak(box, BoxedDestroyed, Nan::WeakCallbackType::kParameter);
 
-    self->SetAlignedPointerInInternalField (0, boxed);
-    self->SetAlignedPointerInInternalField (1, box);
+    Nan::SetInternalFieldPointer(self, 0, boxed);
+    Nan::SetInternalFieldPointer(self, 1, box);
 
     SET_OBJECT_GTYPE (self, gtype);
 
@@ -414,6 +415,13 @@ Local<Function> GetBoxedFunction(GIBaseInfo *info, GType gtype) {
 Local<Function> MakeBoxedClass(GIBaseInfo *info) {
     GType gtype = g_registered_type_info_get_g_type ((GIRegisteredTypeInfo *) info);
 
+    // GVariant is a StructInfo but a refcounted fundamental (G_TYPE_VARIANT),
+    // not a boxed value: give it the fundamental ref/unref wrapper instead of
+    // the boxed copy/free one. JS still attaches its struct methods to this
+    // class via makeBoxed() (#465).
+    if (gtype == G_TYPE_VARIANT)
+        return MakeVariantClass (info);
+
     if (gtype == G_TYPE_NONE) {
         auto moduleCache = GNodeJS::GetModuleCache();
         auto ns   = UTF8 (g_base_info_get_namespace (info));
@@ -454,7 +462,7 @@ Local<Value> WrapperFromBoxed(GIBaseInfo *info, void *data, ResourceOwnership ow
 void* PointerFromWrapper(Local<Value> value) {
     Local<Object> object = TO_OBJECT (value);
     g_assert(object->InternalFieldCount() > 0);
-    void *boxed = object->GetAlignedPointerFromInternalField(0);
+    void *boxed = Nan::GetInternalFieldPointer(object, 0);
     return boxed;
 }
 
@@ -467,12 +475,12 @@ void DisownBoxed(Local<Value> value) {
     if (object->InternalFieldCount() < 2)
         return;
 
-    Boxed *box = static_cast<Boxed *>(object->GetAlignedPointerFromInternalField(1));
+    Boxed *box = static_cast<Boxed *>(Nan::GetInternalFieldPointer(object, 1));
     if (box != NULL) {
         box->owns_memory = false;
         box->data = NULL;
     }
-    object->SetAlignedPointerInInternalField(0, NULL);
+    Nan::SetInternalFieldPointer(object, 0, NULL);
 }
 
 };

package/src/function.cc

@@ -5,6 +5,7 @@
 #include "callback.h"
 #include "debug.h"
 #include "error.h"
+#include "fundamental.h"
 #include "function.h"
 #include "gobject.h"
 #include "macros.h"
@@ -522,11 +523,14 @@ Local<Value> FunctionCall (
                 // Boxed: hand it a copy so the JS wrapper's own memory isn't
                 // double-freed when finalized (#409). GObject: add the reference
                 // the callee will own, so it isn't finalized out from under the
-                // callee once the wrapper is GC'd (#439).
+                // callee once the wrapper is GC'd (#439). Fundamental (e.g.
+                // GskRenderNode): add the reference the callee will own (#468).
                 else if (direction == GI_DIRECTION_IN
                         && g_arg_info_get_ownership_transfer(&arg_info) == GI_TRANSFER_EVERYTHING) {
                     CopyBoxedForTransferFullIn(&type_info, &callable_arg_values[i], param.length);
                     RefObjectForTransferFullIn(&type_info, &callable_arg_values[i]);
+                    RefFundamentalForTransferFullIn(&type_info, &callable_arg_values[i]);
+                    RefVariantForTransferFullIn(&type_info, &callable_arg_values[i]);
                 }
             }
 
@@ -708,7 +712,8 @@ Local<Value> FunctionInfo::JsReturnValue (
         ADD_RETURN (isReturningSelf ? self :
             GIArgumentToV8 (
                 return_type, return_value, length,
-                return_transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone))
+                return_transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone,
+                g_callable_info_may_return_null (info)))
     }
 
     for (int i = 0; i < n_callable_args; i++) {
@@ -742,20 +747,22 @@ Local<Value> FunctionInfo::JsReturnValue (
                         &callable_arg_values[length_i],
                         IsDirectionOut(length_direction));
 
-                Local<Value> result = ArrayToV8(&arg_type, *(void**)arg_value.v_pointer, param.length);
+                bool may_be_null = g_arg_info_may_be_null(&arg_info);
+                Local<Value> result = ArrayToV8(&arg_type, *(void**)arg_value.v_pointer, param.length, may_be_null);
 
                 ADD_RETURN (result)
 
             } else if (param.type == ParameterType::kNORMAL) {
                 GITransfer transfer = g_arg_info_get_ownership_transfer(&arg_info);
                 ResourceOwnership ownership = transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone;
+                bool may_be_null = g_arg_info_may_be_null(&arg_info);
 
                 if (IsPointerType(&arg_type) && g_arg_info_is_caller_allocates(&arg_info)) {
                     void *pointer = &arg_value.v_pointer;
-                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) pointer, -1, ownership))
+                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) pointer, -1, ownership, may_be_null))
                 }
                 else {
-                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) arg_value.v_pointer, -1, ownership))
+                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) arg_value.v_pointer, -1, ownership, may_be_null))
                 }
             }
         }