quickjs 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e13c4664328e497bb8c2179807e8c110c4709b6df84a9a60f888e5a822075de2
-  data.tar.gz: c43d43f3c0b928798545ecf57bf9956df1912e3867220915dd5b13c8aeb0031f
+  metadata.gz: e8f0513a5e0a54c24bdc8c20000f8cf9d1611e394683a710a2260ebedb57913a
+  data.tar.gz: 335ab02e13a0b8b137342f5895bc821641ac33d6f8370e05b9c24f0ca3ce7416
 SHA512:
-  metadata.gz: 581463e6df8d5559f9aa1f91e4512b68f745942d771b2246202d3137a378876c6662db800381abd4dc065b4a6a8acb03f247feda4b78aa9ce1fc31cdd6ed6836
-  data.tar.gz: cd4f64a7d98a75c5e388b99e1cdbd44c6ad4cfc4cd96f8e23259f12aa8cbe18f8c580ad41633cb65c9f77a6f9732fbb6e042b6805cc034a0c4c060f4ecdb3635
+  metadata.gz: f6e975069d7b77adf0d2e4ca7d6459c6499e1465155cae563ff3fb87d7f1f8aefe9f3b26191d9736a2c398ee13df48d5ded389b17f54aec56dc2bf4e4ac580a8
+  data.tar.gz: b1341d5c2e0ba51e6891752bc6c203fe7c2bfc8e1d76beafaf93129f3fb0bb600c64e786beec42ec6a9cc95336562de739d32f02711422b1f9930dd4b57cbb93

data/CLAUDE.md

@@ -55,6 +55,14 @@ Tests use minitest with `describe`/`it` blocks. Key test files:
 - `test/quickjs_test.rb` — Main test suite (value conversion, errors, VM features, ESM imports, function definitions)
 - `test/quickjs_polyfill_test.rb` — Intl polyfill tests
 
+## Release Process
+
+1. On `main`, run `bundle exec rake polyfills:build` — rebuilds polyfill bundles and syncs `polyfills/package.json` version to match the gem version
+2. Bump `lib/quickjs/version.rb` and `Gemfile.lock` to the new version
+3. Commit `lib/quickjs/version.rb`, `Gemfile.lock`, `polyfills/package.json`, `polyfills/package-lock.json` as `"prepare vX.Y.Z"` — do NOT push; `rake release` handles that
+4. Run `bundle exec rake release` — tags, pushes to GitHub, and publishes to RubyGems (human step; do not run this as Claude)
+5. Create a GitHub release via `gh release create` with notes following the pattern of previous releases
+
 ## Build Notes
 
 - `extconf.rb` compiles with `-DNDEBUG` to avoid conflicts with Ruby 4.0 GC assertions

data/README.md

@@ -40,6 +40,13 @@ Quickjs.eval_code(code,
 )
 ```
 
+#### Filename
+
+```rb
+# Label shown in JS stack traces (default: "<code>")
+Quickjs.eval_code(code, filename: 'my_script.js')
+```
+
 #### Timeout
 
 ```rb
@@ -122,6 +129,26 @@ vm.import('DefaultExport', from: File.read('exports.esm.js'))
 vm.import('* as all', from: File.read('exports.esm.js'))
 ```
 
+#### `Quickjs::VM#module_loader=`: 🧩 Resolve `import` specifiers from Ruby
+
+By default, `import` specifiers that aren't already loaded fall through to QuickJS's filesystem loader. Set a `module_loader` Proc to resolve specifiers in-memory instead — useful when the source code lives in a database, an importmap, or a virtual filesystem.
+
+```rb
+vm = Quickjs::VM.new
+modules = {
+  'a' => "import { b } from 'b'; export const a = () => `a-${b()}`;",
+  'b' => "export const b = () => 'b-result';"
+}
+vm.module_loader = ->(name) { modules[name] }
+
+vm.import(['a'], filename: 'a')
+vm.eval_code('a()') #=> 'a-b-result'
+```
+
+The Proc receives the (already normalized) module specifier and returns the module source as a `String`, or `nil` to signal "not found" (which raises `Quickjs::ReferenceError` on the JS side). Pass `nil` to clear a previously set loader.
+
+When `module_loader=` is set, pass `filename:` to `import` instead of `from:` to resolve a named specifier directly through the loader — no inline bridge source needed.
+
 #### `Quickjs::VM#define_function`: 💎 Define a global function for JS by Ruby
 
 ```rb
@@ -133,6 +160,23 @@ end
 vm.eval_code("greetingTo('Rick')") #=> 'Hello! Rick'
 ```
 
+Pass an `Array` as the name to register the function on an existing JS object (the last element is the method name; preceding elements are the object path):
+
+```rb
+vm = Quickjs::VM.new
+vm.eval_code("const myLib = {}")
+vm.define_function(["myLib", "greetingTo"]) { |name| "Hello, #{name}!" }
+
+vm.eval_code("myLib.greetingTo('Rick')") #=> 'Hello! Rick'
+
+# Deeply nested
+vm.eval_code("const a = { b: { c: {} } }")
+vm.define_function(["a", "b", "c", "double"]) { |x| x * 2 }
+vm.eval_code("a.b.c.double(21)") #=> 42
+```
+
+`define_function` returns the registered name as a `Symbol` (or an `Array` of `Symbol`s for array paths).
+
 A Ruby exception raised inside the block is catchable in JS as an `Error`, and propagates back to Ruby as the original exception type if uncaught in JS.
 
 ```rb
@@ -177,14 +221,20 @@ vm.eval_code('console.log("hello", 42)')
 | `string` | ↔ | `String` | |
 | `true` / `false` | ↔ | `true` / `false` | |
 | `null` | ↔ | `nil` | |
-| `Array` | ↔ | `Array` | via JSON |
-| `Object` | ↔ | `Hash` | via JSON |
+| `Array` | ↔ | `Array` | recursively converted |
+| `Object` | ↔ | `Hash` | recursively converted; keys are always `String` |
+| `function` | → | `Quickjs::Function` — `.source`, `.call(*args, on:)` | |
 | `undefined` | → | `Quickjs::Value::UNDEFINED` | |
 | `NaN` | → | `Quickjs::Value::NAN` | |
 | `Blob` | → | `Quickjs::Blob` — `.size`, `.type`, `.content` | requires `POLYFILL_FILE` |
 | `File` | → | `Quickjs::File` — `.name`, `.last_modified` + Blob attrs | requires `POLYFILL_FILE` |
 | `File` proxy | ← | `::File` | requires `POLYFILL_FILE`; applies to `define_function` return values |
 
+## Acknowledgements
+
+- [@ursm](https://github.com/ursm) — for continuous contributions improving performance and developer experience
+- [@persona-id](https://github.com/persona-id) — for providing real-world use cases that shape the direction of this project
+
 ## License
 
 - `ext/quickjsrb/quickjs`

data/ext/quickjsrb/quickjsrb.c

@@ -57,8 +57,21 @@ typedef struct
 static int rb_hash_entry_to_js(VALUE r_key, VALUE r_val, VALUE extra)
 {
   RbHashToJsArg *arg = (RbHashToJsArg *)extra;
-  VALUE r_key_str = rb_funcall(r_key, rb_intern("to_s"), 0);
-  JS_SetPropertyStr(arg->ctx, arg->j_obj, StringValueCStr(r_key_str), to_js_value(arg->ctx, r_val));
+  const char *key_cstr;
+  if (SYMBOL_P(r_key))
+  {
+    key_cstr = rb_id2name(SYM2ID(r_key));
+  }
+  else if (RB_TYPE_P(r_key, T_STRING))
+  {
+    key_cstr = StringValueCStr(r_key);
+  }
+  else
+  {
+    VALUE r_key_str = rb_funcall(r_key, rb_intern("to_s"), 0);
+    key_cstr = StringValueCStr(r_key_str);
+  }
+  JS_SetPropertyStr(arg->ctx, arg->j_obj, key_cstr, to_js_value(arg->ctx, r_val));
   return ST_CONTINUE;
 }
 
@@ -69,26 +82,23 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   case T_NIL:
     return JS_NULL;
   case T_FIXNUM:
+    return JS_NewInt64(ctx, NUM2LL(r_value));
   case T_FLOAT:
+    return JS_NewFloat64(ctx, NUM2DBL(r_value));
+  case T_BIGNUM:
   {
     VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0);
-    char *str = StringValueCStr(r_str);
+    JSValue j_str = JS_NewStringLen(ctx, RSTRING_PTR(r_str), RSTRING_LEN(r_str));
     JSValue j_global = JS_GetGlobalObject(ctx);
     JSValue j_numberClass = JS_GetPropertyStr(ctx, j_global, "Number");
-    JSValue j_str = JS_NewString(ctx, str);
-    JSValue j_stringified = JS_Call(ctx, j_numberClass, JS_UNDEFINED, 1, (JSValueConst *)&j_str);
-    JS_FreeValue(ctx, j_global);
-    JS_FreeValue(ctx, j_numberClass);
+    JSValue j_num = JS_Call(ctx, j_numberClass, JS_UNDEFINED, 1, (JSValueConst *)&j_str);
     JS_FreeValue(ctx, j_str);
-
-    return j_stringified;
+    JS_FreeValue(ctx, j_numberClass);
+    JS_FreeValue(ctx, j_global);
+    return j_num;
   }
   case T_STRING:
-  {
-    char *str = StringValueCStr(r_value);
-
-    return JS_NewString(ctx, str);
-  }
+    return JS_NewStringLen(ctx, RSTRING_PTR(r_value), RSTRING_LEN(r_value));
   case T_SYMBOL:
   {
     if (r_value == QUICKJSRB_SYM(undefinedId))
@@ -100,10 +110,8 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
       JS_FreeValue(ctx, j_global);
       return j_nan;
     }
-    VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0);
-    char *str = StringValueCStr(r_str);
-
-    return JS_NewString(ctx, str);
+    const char *name = rb_id2name(SYM2ID(r_value));
+    return JS_NewString(ctx, name);
   }
   case T_TRUE:
     return JS_TRUE;
@@ -134,10 +142,7 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
       if (!JS_IsUndefined(data->j_file_proxy_creator))
         return quickjsrb_file_to_js(ctx, r_value);
     }
-    if (TYPE(r_value) == T_OBJECT && RTEST(rb_funcall(
-                                         r_value,
-                                         rb_intern("is_a?"),
-                                         1, rb_const_get(rb_cClass, rb_intern("Exception")))))
+    if (rb_obj_is_kind_of(r_value, rb_eException))
     {
       return j_error_from_ruby_error(ctx, r_value);
     }
@@ -266,16 +271,13 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
   }
   case JS_TAG_STRING:
   {
-    int couldntParse;
-    VALUE r_result = rb_protect(r_try_json_parse, to_r_json(ctx, j_val), &couldntParse);
-    if (couldntParse)
-    {
+    size_t len;
+    const char *str = JS_ToCStringLen(ctx, &len, j_val);
+    if (str == NULL)
       return Qnil;
-    }
-    else
-    {
-      return r_result;
-    }
+    VALUE r_str = rb_utf8_str_new(str, (long)len);
+    JS_FreeCString(ctx, str);
+    return r_str;
   }
   case JS_TAG_OBJECT:
   {
@@ -468,6 +470,59 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
   }
 }
 
+struct module_loader_call_args
+{
+  VALUE proc;
+  VALUE r_module_name;
+};
+
+static VALUE r_module_loader_call(VALUE r_args_val)
+{
+  struct module_loader_call_args *args = (struct module_loader_call_args *)r_args_val;
+  return rb_funcall(args->proc, rb_intern("call"), 1, args->r_module_name);
+}
+
+static JSModuleDef *quickjsrb_module_loader(JSContext *ctx, const char *module_name, void *opaque, JSValueConst attributes)
+{
+  VMData *data = JS_GetContextOpaque(ctx);
+  if (NIL_P(data->module_loader))
+    return js_module_loader(ctx, module_name, opaque, attributes);
+
+  struct module_loader_call_args args = {data->module_loader, rb_str_new_cstr(module_name)};
+  int state;
+  VALUE r_source = rb_protect(r_module_loader_call, (VALUE)&args, &state);
+  if (state)
+  {
+    VALUE r_error = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    JSValue j_error = j_error_from_ruby_error(ctx, r_error);
+    JS_Throw(ctx, j_error);
+    return NULL;
+  }
+
+  if (NIL_P(r_source) || r_source == Qfalse)
+  {
+    JS_ThrowReferenceError(ctx, "module loader returned no source for '%s'", module_name);
+    return NULL;
+  }
+
+  if (!RB_TYPE_P(r_source, T_STRING))
+  {
+    JS_ThrowTypeError(ctx, "module loader must return a String or nil, got %s", rb_obj_classname(r_source));
+    return NULL;
+  }
+
+  JSValue j_func = JS_Eval(ctx, RSTRING_PTR(r_source), RSTRING_LEN(r_source), module_name,
+                           JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+  if (JS_IsException(j_func))
+    return NULL;
+
+  js_module_set_import_meta(ctx, j_func, FALSE, FALSE);
+  JSModuleDef *m = JS_VALUE_GET_PTR(j_func);
+  JS_FreeValue(ctx, j_func);
+  return m;
+}
+
 static VALUE r_try_call_proc(VALUE r_try_args)
 {
   return rb_funcall(
@@ -482,16 +537,19 @@ static VALUE r_try_call_proc(VALUE r_try_args)
 
 static JSValue js_quickjsrb_call_global(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, int _magic, JSValue *func_data)
 {
-  const char *funcName = JS_ToCString(ctx, func_data[0]);
+  // func_data[0] holds the Ruby Symbol ID for the defined function (stored by
+  // vm_m_defineGlobalFunction). Looking up by ID avoids a JS_ToCString +
+  // rb_intern round-trip on every call.
+  int64_t key_id;
+  JS_ToInt64(ctx, &key_id, func_data[0]);
 
   VMData *data = JS_GetContextOpaque(ctx);
-  VALUE r_proc = rb_hash_aref(data->defined_functions, ID2SYM(rb_intern(funcName)));
+  VALUE r_proc = rb_hash_aref(data->defined_functions, ID2SYM((ID)key_id));
   // Shouldn't happen
   if (r_proc == Qnil)
   {
-    return JS_ThrowReferenceError(ctx, "Proc `%s` is not defined", funcName); // TODO: Free funcnName
+    return JS_ThrowReferenceError(ctx, "Proc is not defined");
   }
-  JS_FreeCString(ctx, funcName);
 
   VALUE r_call_args = rb_ary_new();
   rb_ary_push(r_call_args, r_proc);
@@ -727,7 +785,7 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
   JS_SetMemoryLimit(runtime, NUM2UINT(r_memory_limit));
   JS_SetMaxStackSize(runtime, NUM2UINT(r_max_stack_size));
 
-  JS_SetModuleLoaderFunc2(runtime, NULL, js_module_loader, js_module_check_attributes, NULL);
+  JS_SetModuleLoaderFunc2(runtime, NULL, quickjsrb_module_loader, js_module_check_attributes, NULL);
   js_std_init_handlers(runtime);
 
   JSValue j_global = JS_GetGlobalObject(data->context);
@@ -842,22 +900,36 @@ static VALUE to_rb_return_value(JSContext *ctx, JSValue j_val)
   return result;
 }
 
-static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
+static VALUE vm_m_evalCode(int argc, VALUE *argv, VALUE r_self)
 {
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
+  VALUE r_code, r_opts;
+  rb_scan_args(argc, argv, "1:", &r_code, &r_opts);
+
   if (!RB_TYPE_P(r_code, T_STRING))
   {
     VALUE r_code_class = rb_class_name(CLASS_OF(r_code));
     rb_raise(rb_eTypeError, "JavaScript code must be a String, got %s", StringValueCStr(r_code_class));
   }
 
+  const char *filename = "<code>";
+  if (!NIL_P(r_opts))
+  {
+    VALUE r_filename = rb_hash_aref(r_opts, ID2SYM(rb_intern("filename")));
+    if (!NIL_P(r_filename))
+    {
+      Check_Type(r_filename, T_STRING);
+      filename = StringValueCStr(r_filename);
+    }
+  }
+
   clock_gettime(CLOCK_MONOTONIC, &data->eval_time->started_at);
   JS_SetInterruptHandler(JS_GetRuntime(data->context), interrupt_handler, data->eval_time);
 
-  char *code = StringValueCStr(r_code);
-  JSValue j_codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
+  StringValue(r_code);
+  JSValue j_codeResult = JS_Eval(data->context, RSTRING_PTR(r_code), RSTRING_LEN(r_code), filename, JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
   JSValue j_awaitedResult = js_std_await(data->context, j_codeResult); // This frees j_codeResult
   // JS_EVAL_FLAG_ASYNC wraps the result in {value, done} — extract the actual value
   // Free j_awaitedResult before to_rb_return_value because it may raise (longjmp), which would skip cleanup
@@ -904,7 +976,7 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
     char *funcName = StringValueCStr(r_func_seg_str);
 
     JSValueConst ruby_data[2];
-    ruby_data[0] = JS_NewString(data->context, StringValueCStr(r_key_str));
+    ruby_data[0] = JS_NewInt64(data->context, (int64_t)SYM2ID(r_key_sym));
     ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
 
     // Resolve the parent object to attach the function to.
@@ -969,7 +1041,7 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
     char *funcName = StringValueCStr(r_name_str);
 
     JSValueConst ruby_data[2];
-    ruby_data[0] = JS_NewString(data->context, funcName);
+    ruby_data[0] = JS_NewInt64(data->context, (int64_t)SYM2ID(r_name_sym));
     ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
 
     JSValue j_global = JS_GetGlobalObject(data->context);
@@ -1124,6 +1196,25 @@ static VALUE vm_m_callGlobalFunction(int argc, VALUE *argv, VALUE r_self)
   return to_rb_return_value(data->context, js_std_await(data->context, j_result));
 }
 
+static VALUE vm_m_set_module_loader(VALUE r_self, VALUE r_loader)
+{
+  VMData *data;
+  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
+
+  if (!NIL_P(r_loader) && !rb_obj_is_kind_of(r_loader, rb_cProc))
+    rb_raise(rb_eTypeError, "module_loader must be a Proc or nil");
+
+  data->module_loader = r_loader;
+  return r_loader;
+}
+
+static VALUE vm_m_get_module_loader(VALUE r_self)
+{
+  VMData *data;
+  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
+  return data->module_loader;
+}
+
 static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
 {
   VALUE r_import_string, r_opts;
@@ -1131,7 +1222,8 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   if (NIL_P(r_opts))
     r_opts = rb_hash_new();
   VALUE r_from = rb_hash_aref(r_opts, ID2SYM(rb_intern("from")));
-  if (NIL_P(r_from))
+  VALUE r_filename = rb_hash_aref(r_opts, ID2SYM(rb_intern("filename")));
+  if (NIL_P(r_from) && NIL_P(r_filename))
   {
     VALUE r_error_message = rb_str_new2("missing import source");
     rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
@@ -1142,16 +1234,24 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
-  char *filename = random_string();
-  char *source = StringValueCStr(r_from);
-  JSValue module = JS_Eval(data->context, source, strlen(source), filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
-  if (JS_IsException(module))
+  char *filename;
+  if (!NIL_P(r_filename))
   {
+    filename = StringValueCStr(r_filename);
+  }
+  else
+  {
+    filename = random_string();
+    char *source = StringValueCStr(r_from);
+    JSValue module = JS_Eval(data->context, source, strlen(source), filename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+    if (JS_IsException(module))
+    {
+      JS_FreeValue(data->context, module);
+      return to_rb_value(data->context, module);
+    }
+    js_module_set_import_meta(data->context, module, TRUE, FALSE);
     JS_FreeValue(data->context, module);
-    return to_rb_value(data->context, module);
   }
-  js_module_set_import_meta(data->context, module, TRUE, FALSE);
-  JS_FreeValue(data->context, module);
 
   VALUE r_import_settings = rb_funcall(
       rb_const_get(rb_cClass, rb_intern("Quickjs")),
@@ -1196,10 +1296,12 @@ RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
   VALUE r_class_vm = rb_define_class_under(r_module_quickjs, "VM", rb_cObject);
   rb_define_alloc_func(r_class_vm, vm_alloc);
   rb_define_method(r_class_vm, "initialize", vm_m_initialize, -1);
-  rb_define_method(r_class_vm, "eval_code", vm_m_evalCode, 1);
+  rb_define_method(r_class_vm, "eval_code", vm_m_evalCode, -1);
   rb_define_method(r_class_vm, "call", vm_m_callGlobalFunction, -1);
   rb_define_method(r_class_vm, "define_function", vm_m_defineGlobalFunction, -1);
   rb_define_method(r_class_vm, "import", vm_m_import, -1);
+  rb_define_method(r_class_vm, "module_loader", vm_m_get_module_loader, 0);
+  rb_define_method(r_class_vm, "module_loader=", vm_m_set_module_loader, 1);
   rb_define_method(r_class_vm, "on_log", vm_m_on_log, 0);
   r_define_log_class(r_class_vm);
 }

data/ext/quickjsrb/quickjsrb.h

@@ -54,6 +54,7 @@ typedef struct VMData
   struct EvalTime *eval_time;
   VALUE log_listener;
   VALUE alive_objects;
+  VALUE module_loader;
   JSValue j_file_proxy_creator;
 } VMData;
 
@@ -85,6 +86,7 @@ static void vm_mark(void *ptr)
   rb_gc_mark_movable(data->defined_functions);
   rb_gc_mark_movable(data->log_listener);
   rb_gc_mark_movable(data->alive_objects);
+  rb_gc_mark_movable(data->module_loader);
 }
 
 static void vm_compact(void *ptr)
@@ -93,6 +95,7 @@ static void vm_compact(void *ptr)
   data->defined_functions = rb_gc_location(data->defined_functions);
   data->log_listener = rb_gc_location(data->log_listener);
   data->alive_objects = rb_gc_location(data->alive_objects);
+  data->module_loader = rb_gc_location(data->module_loader);
 }
 
 static const rb_data_type_t vm_type = {
@@ -113,6 +116,7 @@ static VALUE vm_alloc(VALUE r_self)
   data->defined_functions = rb_hash_new();
   data->log_listener = Qnil;
   data->alive_objects = rb_hash_new();
+  data->module_loader = Qnil;
   data->j_file_proxy_creator = JS_UNDEFINED;
 
   EvalTime *eval_time = malloc(sizeof(EvalTime));

data/lib/quickjs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quickjs
-  VERSION = "0.15.0"
+  VERSION = "0.16.0"
 end

data/lib/quickjs.rb

@@ -18,8 +18,10 @@ module Quickjs
   end
 
   def eval_code(code, overwrite_opts = {})
+    eval_opts = {}
+    eval_opts[:filename] = overwrite_opts.delete(:filename) if overwrite_opts.key?(:filename)
     vm = Quickjs::VM.new(**overwrite_opts)
-    res = vm.eval_code(code)
+    res = vm.eval_code(code, **eval_opts)
     vm = nil
     res
   end

data/polyfills/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "quickjs-rb-polyfills",
-      "version": "0.15.0",
+      "version": "0.16.0",
       "dependencies": {
         "@formatjs/intl-datetimeformat": "^7.3.1",
         "@formatjs/intl-getcanonicallocales": "^3.2.2",

data/polyfills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickjs-rb-polyfills",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "private": true,
   "scripts": {
     "build": "rolldown -c rolldown.config.mjs",

data/sig/quickjs.rbs

@@ -21,7 +21,7 @@ module Quickjs
   class VM
     def initialize: (?features: Array[Symbol], ?memory_limit: Integer, ?max_stack_size: Integer, ?timeout_msec: Integer) -> void
 
-    def eval_code: (String code) -> untyped
+    def eval_code: (String code, ?filename: String) -> untyped
 
     def call: (String | Symbol name, *untyped args) -> untyped
 
@@ -29,6 +29,11 @@ module Quickjs
                        | (Array[String | Symbol] path, *Symbol flags) { (*untyped) -> untyped } -> Array[Symbol]
 
     def import: (String | Array[String] | Hash[Symbol, String] imported, from: String, ?code_to_expose: String?) -> true
+              | (String | Array[String] | Hash[Symbol, String] imported, filename: String) -> true
+
+    def module_loader: () -> (^(String) -> String? | nil)
+
+    def module_loader=: (^(String) -> String? | nil) -> (^(String) -> String? | nil)
 
     def on_log: () { (Log) -> void } -> nil
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quickjs
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - hmsk