@gjsify/node-gi 0.63.0 → 0.64.1

package/src/object.cc

@@ -444,17 +444,53 @@ bool JsToGValue(Napi::Env env, Napi::Value js, GValue* v) {
     // napi failure mid worker.terminate() must degrade to a zero, not cascade
     // into Error::New(nullptr)'s fatal sites (the terminate-mid-`newObject` path).
     case G_TYPE_BOOLEAN: g_value_set_boolean(v, NodeGiToBool(js)); return true;
-    case G_TYPE_CHAR: g_value_set_schar(v, static_cast<gint8>(NodeGiToInt32(js))); return true;
-    case G_TYPE_UCHAR: g_value_set_uchar(v, static_cast<guchar>(NodeGiToUint32(js))); return true;
-    case G_TYPE_INT: g_value_set_int(v, NodeGiToInt32(js)); return true;
-    case G_TYPE_UINT: g_value_set_uint(v, NodeGiToUint32(js)); return true;
-    // 64-bit (glong/gulong are 64-bit on LP64): accept a BigInt losslessly, else a
-    // truncated Number — never let a BigInt reach ToNumber(). Shared with the GI
-    // scalar marshaller via JsValueTo{Int,Uint}64 (common.h).
+    // char/uchar/int64/uint64 refuse an out-of-range value and int/uint wrap, as gjs's
+    // gjs_value_to_g_value does (value.cpp:602-690) — the same rule the constructor
+    // properties and signal arguments reach. A BigInt on a 32-bit tag is ToNumber's
+    // TypeError, left pending.
+    case G_TYPE_CHAR:
+    case G_TYPE_UCHAR:
+    case G_TYPE_INT64:
+    case G_TYPE_UINT64: {
+      GITypeTag tag = ft == G_TYPE_CHAR    ? GI_TYPE_TAG_INT8
+                      : ft == G_TYPE_UCHAR ? GI_TYPE_TAG_UINT8
+                      : ft == G_TYPE_INT64 ? GI_TYPE_TAG_INT64
+                                           : GI_TYPE_TAG_UINT64;
+      GIArgument a;
+      memset(&a, 0, sizeof(a));
+      switch (NodeGiJsToInteger(js, tag, &a, nullptr)) {
+        case NodeGiIntResult::kPending: return false;
+        case NodeGiIntResult::kOutOfRange:
+          NodeGiThrowGValueOutOfRange(env, js,
+                                      ft == G_TYPE_CHAR    ? "char"
+                                      : ft == G_TYPE_UCHAR ? "unsigned char"
+                                      : ft == G_TYPE_INT64 ? "64-bit integer"
+                                                           : "unsigned 64-bit integer");
+          return false;
+        case NodeGiIntResult::kOk: break;
+      }
+      if (ft == G_TYPE_CHAR) g_value_set_schar(v, a.v_int8);
+      else if (ft == G_TYPE_UCHAR) g_value_set_uchar(v, a.v_uint8);
+      else if (ft == G_TYPE_INT64) g_value_set_int64(v, a.v_int64);
+      else g_value_set_uint64(v, a.v_uint64);
+      return true;
+    }
+    case G_TYPE_INT:
+    case G_TYPE_UINT: {
+      GIArgument a;
+      memset(&a, 0, sizeof(a));
+      if (NodeGiJsToIntegerWrap(js, ft == G_TYPE_INT ? GI_TYPE_TAG_INT32 : GI_TYPE_TAG_UINT32,
+                                &a) == NodeGiIntResult::kPending)
+        return false;
+      if (ft == G_TYPE_INT) g_value_set_int(v, a.v_int32);
+      else g_value_set_uint(v, a.v_uint32);
+      return true;
+    }
+    // glong/gulong are 64-bit on LP64: accept a BigInt losslessly, else a truncated
+    // Number — never let a BigInt reach ToNumber(). Shared with the GI scalar marshaller
+    // via JsValueTo{Int,Uint}64 (common.h). gjs has no G_TYPE_LONG case here at all.
     case G_TYPE_LONG: g_value_set_long(v, static_cast<glong>(JsValueToInt64(js))); return true;
     case G_TYPE_ULONG: g_value_set_ulong(v, static_cast<gulong>(JsValueToUint64(js))); return true;
-    case G_TYPE_INT64: g_value_set_int64(v, JsValueToInt64(js)); return true;
-    case G_TYPE_UINT64: g_value_set_uint64(v, JsValueToUint64(js)); return true;
     case G_TYPE_FLOAT: g_value_set_float(v, static_cast<float>(NodeGiToDouble(js))); return true;
     case G_TYPE_DOUBLE: g_value_set_double(v, NodeGiToDouble(js)); return true;
     case G_TYPE_ENUM: g_value_set_enum(v, NodeGiToInt32(js)); return true;
@@ -611,7 +647,16 @@ Napi::Value ConstructGObject(Napi::Env env, GType gtype, Napi::Object props,
     }
     g_value_init(&values[i], pspec->value_type);
     initialised = i + 1;
-    if (!JsToGValue(env, props.Get(nameStorage[i]), &values[i])) {
+    Napi::Value propValue = props.Get(nameStorage[i]);
+    if (!propValue.IsEmpty() && propValue.IsUndefined()) {
+      // gjs refuses `undefined` for every property type (object.cpp:2090).
+      Napi::Error::New(env, "Invalid value 'undefined' for property " + std::string(pspec->name) +
+                                " in object initializer.")
+          .ThrowAsJavaScriptException();
+      ok = false;
+      break;
+    }
+    if (!JsToGValue(env, propValue, &values[i])) {
       ok = false;
       break;
     }
@@ -734,6 +779,30 @@ Napi::Value SetProperty(const Napi::CallbackInfo& info) {
     Napi::TypeError::New(env, "no such property '" + name + "'").ThrowAsJavaScriptException();
     return env.Undefined();
   }
+  // gjs refuses an out-of-range value for these property types on assignment
+  // (object.cpp, with its own text); JsToGValue below now refuses them too, with the
+  // gjs_value_to_g_value text.
+  GITypeTag intTag = GI_TYPE_TAG_VOID;
+  switch (G_TYPE_FUNDAMENTAL(pspec->value_type)) {
+    case G_TYPE_CHAR: intTag = GI_TYPE_TAG_INT8; break;
+    case G_TYPE_UCHAR: intTag = GI_TYPE_TAG_UINT8; break;
+    case G_TYPE_UINT: intTag = GI_TYPE_TAG_UINT32; break;
+    case G_TYPE_INT64: intTag = GI_TYPE_TAG_INT64; break;
+    case G_TYPE_UINT64: intTag = GI_TYPE_TAG_UINT64; break;
+    default: break;
+  }
+  if (intTag != GI_TYPE_TAG_VOID) {
+    GIArgument probe;
+    std::string shown;
+    NodeGiIntResult r = NodeGiJsToInteger(info[2], intTag, &probe, &shown);
+    if (r == NodeGiIntResult::kPending) return env.Undefined();
+    if (r == NodeGiIntResult::kOutOfRange) {
+      Napi::Error::New(env, "value " + shown + " is out of range for " + pspec->name +
+                                " (type " + NodeGiIntTagName(intTag) + ")")
+          .ThrowAsJavaScriptException();
+      return env.Undefined();
+    }
+  }
   GValue v = G_VALUE_INIT;
   g_value_init(&v, pspec->value_type);
   if (JsToGValue(env, info[2], &v)) {

package/src/private.cc

@@ -25,6 +25,10 @@
 
 #include "common.h"
 
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 namespace nodegi {
 
 // ---- GLib.log_set_writer_func ----------------------------------------------
@@ -557,10 +561,39 @@ Napi::Value Bindtextdomain(const Napi::CallbackInfo& info) {
     }
     location = info[1].As<Napi::String>().Utf8Value();
   }
+#ifdef _WIN32
+  // bindtextdomain() reads its path in the ANSI code page, so a UTF-8 JS string with
+  // a non-ASCII directory (".../Steuererklärung/share/locale") binds a path that
+  // does not exist and every lookup silently answers the msgid (measured in a Windows
+  // 11 VM: the same catalog under an ASCII path translated). GNU gettext >= 0.21
+  // ships wbindtextdomain() for exactly this; both directions go through UTF-16.
+  std::wstring wlocation;
+  if (!query) {
+    int n = MultiByteToWideChar(CP_UTF8, 0, location.c_str(), -1, nullptr, 0);
+    if (n <= 0) {
+      Napi::TypeError::New(env, "bindtextdomain: location is not valid UTF-8")
+          .ThrowAsJavaScriptException();
+      return env.Null();
+    }
+    wlocation.resize(n);
+    MultiByteToWideChar(CP_UTF8, 0, location.c_str(), -1, wlocation.data(), n);
+    wlocation.resize(n - 1);
+  }
+  const wchar_t* wresult = wbindtextdomain(domain.c_str(), query ? nullptr : wlocation.c_str());
+  if (!query) bind_textdomain_codeset(domain.c_str(), "UTF-8");
+  if (wresult == nullptr) return env.Null();
+  int len = WideCharToMultiByte(CP_UTF8, 0, wresult, -1, nullptr, 0, nullptr, nullptr);
+  if (len <= 0) return env.Null();
+  std::string utf8(len, '\0');
+  WideCharToMultiByte(CP_UTF8, 0, wresult, -1, utf8.data(), len, nullptr, nullptr);
+  utf8.resize(len - 1);
+  return Napi::String::New(env, utf8);
+#else
   const char* result = bindtextdomain(domain.c_str(), query ? nullptr : location.c_str());
   if (!query) bind_textdomain_codeset(domain.c_str(), "UTF-8");
   if (result == nullptr) return env.Null();
   return Napi::String::New(env, result);
+#endif
 }
 
 // localeCategories() -> { ALL, COLLATE, CTYPE, MESSAGES, MONETARY, NUMERIC, TIME }

package/src/repo.cc

@@ -13,7 +13,6 @@ void NodeGiEnvDataFinalize(napi_env env, void* data, void* /*hint*/) {
   NodeGiEnvData* d = static_cast<NodeGiEnvData*>(data);
   if (d == nullptr) return;
   if (d->errorBuilder != nullptr) napi_delete_reference(env, d->errorBuilder);
-  if (d->errorClass != nullptr) napi_delete_reference(env, d->errorClass);
   if (d->templateCallbackResolver != nullptr)
     napi_delete_reference(env, d->templateCallbackResolver);
   if (d->cairoWrappers != nullptr) napi_delete_reference(env, d->cairoWrappers);
@@ -260,17 +259,52 @@ Napi::Value GetErrorDomain(const Napi::CallbackInfo& info) {
   return result;
 }
 
-// setErrorBuilder(builder: (domainName, domainQuark, code, message) => Error,
-//                 errorClass?: typeof GLib.Error) -> void
-// Register the L1 GLib.Error factory the engine calls when a GI invoke fails, so a
-// failed sync call throws a real GLib.Error, together with the class it builds —
-// which the GError IN-arg path needs to recognise one coming back. Both stored
-// per-env (a napi_ref is env-specific; both paths are gated on the same env), in
-// ONE call so a registration cannot supply the builder and forget the class.
+// errorDomainInfo(quark: number) -> { namespace: string, name: string } | null
+// Which introspected enum registered a GError domain quark, so L1 can resolve a
+// thrown error to its DOMAIN CLASS (Gio.IOErrorEnum) by reading that member.
+// getErrorDomain below answers the same relation the other way round, and L1's
+// quark→class map is only populated by it — which is not enough on its own: an
+// application that never named `Gio.IOErrorEnum` has nothing in the map, and the
+// error it catches would land on the base class, breaking exactly the
+// `catch (e) { if (e instanceof Gio.IOErrorEnum) }` idiom. Null for a quark no
+// typelib registers (a private `GLib.quark_from_string` domain).
+Napi::Value ErrorDomainInfo(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 1 || !info[0].IsNumber()) {
+    Napi::TypeError::New(env, "errorDomainInfo(quark: number)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  GQuark quark = static_cast<GQuark>(NodeGiToUint32(info[0]));
+  if (quark == 0) return env.Null();
+  GIRepository* repo = DupDefaultRepository();
+  GIEnumInfo* enumInfo = gi_repository_find_by_error_domain(repo, quark);
+  Napi::Value result = env.Null();
+  if (enumInfo != nullptr) {
+    GIBaseInfo* base = reinterpret_cast<GIBaseInfo*>(enumInfo);
+    const char* ns = gi_base_info_get_namespace(base);
+    const char* name = gi_base_info_get_name(base);
+    if (ns != nullptr && name != nullptr) {
+      Napi::Object obj = Napi::Object::New(env);
+      obj.Set("namespace", Napi::String::New(env, ns));
+      obj.Set("name", Napi::String::New(env, name));
+      result = obj;
+    }
+    gi_base_info_unref(base);
+  }
+  g_object_unref(repo);
+  return result;
+}
+
+// setErrorBuilder(builder: (handle) => GLib.Error) -> void
+// Register the L1 error factory the engine calls when a GI invoke fails, so a
+// failed sync call throws the error object of its domain's class. Stored per-env
+// (a napi_ref is env-specific). It takes the GError's boxed HANDLE — the L1 error
+// IS that handle, which is why nothing else needs registering here: the GError
+// IN-arg direction reads the same handle back off the object.
 Napi::Value SetErrorBuilder(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (info.Length() < 1 || !info[0].IsFunction()) {
-    Napi::TypeError::New(env, "setErrorBuilder(builder: function, errorClass?: function)")
+    Napi::TypeError::New(env, "setErrorBuilder(builder: function)")
         .ThrowAsJavaScriptException();
     return env.Undefined();
   }
@@ -281,12 +315,6 @@ Napi::Value SetErrorBuilder(const Napi::CallbackInfo& info) {
     d->errorBuilder = nullptr;
   }
   napi_create_reference(env, info[0], 1, &d->errorBuilder);
-  if (d->errorClass != nullptr) {
-    napi_delete_reference(env, d->errorClass);
-    d->errorClass = nullptr;
-  }
-  if (info.Length() >= 2 && info[1].IsFunction())
-    napi_create_reference(env, info[1], 1, &d->errorClass);
   return env.Undefined();
 }