wip

Author: andrieshiemstra

.github/workflows/rust.yml

@@ -68,6 +68,19 @@ jobs:
     - name: Run tests
       run: cargo test --verbose
 
+  build-ubuntu-quickjs-ng:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Prepare
+        run: |
+          sudo apt update
+          sudo apt install llvm autoconf2.13 automake clang -y
+      - name: Run tests
+        run: cargo test --verbose --no-default-features --features quickjs-ng console setimmediate setinterval settimeout typescript
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+
   build:
     runs-on: ubuntu-latest
     steps:

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.14.5
+
+* quickjs-ng 0.8.0
+
 # 0.14.4
 
 * don't panic on utf8 error in to_str

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "quickjs_runtime"
-version = "0.14.4"
+version = "0.14.5"
 authors = ["Andries Hiemstra <info@hirofa.com>"]
 edition = "2021"
 description = "Wrapper API and utils for the QuickJS JavaScript engine with support for Promise, Modules, Async/await"
@@ -31,7 +31,7 @@ backtrace = "0.3.67"
 
 #libquickjs-sys = {package="hirofa-quickjs-sys", git='https://github.com/HiRoFa/quickjs-sys'}
 #libquickjs-sys = {package="hirofa-quickjs-sys", path='../quickjs-sys', default-features=false}
-libquickjs-sys = {package="hirofa-quickjs-sys", version="0.6.0", default-features=false}
+libquickjs-sys = {package="hirofa-quickjs-sys", version="0.8.0", default-features=false}
 lazy_static = "1.4.0"
 log = "0.4"
 num_cpus = "1"

README.md

@@ -1,14 +1,14 @@
 # quickjs_runtime
 
-quickjs_runtime is a library for quickly getting started with embedding a javascript engine in your rust project.
+Quickjs_runtime is a library for quickly getting started with embedding a javascript engine in your rust project.
 
-**as of 2024 this lib no longer relies on [libquickjs-sys](https://github.com/theduke/quickjs-rs/tree/master/libquickjs-sys) but on our own [hirofa-quickjs-sys](https://github.com/HiRoFa/quickjs-sys) adding flexibility in used quickjs version**
+Relies on [hirofa-quickjs-sys](https://github.com/HiRoFa/quickjs-sys) to support quickjs-ng as well as the original quickjs
 
-quickjs_runtime runs all javascript action in a single thread using an EventLoop. This means you can call javascript safely from several threads by adding tasks to the EventLoop.
+Quickjs_runtime runs all javascript action in a single thread using an EventLoop. This means you can call javascript safely from several threads by adding tasks to the EventLoop.
 
 # quickjs or quickjs-ng
 
-quickjs_runtime supports both the original quickjs and the quickjs-ng project.
+Quickjs_runtime supports both the original quickjs and the quickjs-ng project.
 
 You can try out quickjs-ng by adding the dep to quickjs_runtime like this (use at your own risk as I have not extensively tested it yet):
 ```toml
@@ -19,7 +19,7 @@ quickjs_runtime = {git="https://github.com/HiRoFa/quickjs_es_runtime", features=
 
 An example on how to embed a script engine in rust using this lib can be found here: [github.com/andrieshiemstra/ScriptExtensionLayerExample](https://github.com/andrieshiemstra/ScriptExtensionLayerExample). It was published in TWIR as a walkthrough. 
 
-quickjs_runtime focuses on making [quickjs](https://bellard.org/quickjs/) easy to use and does not add any additional features, that's where these projects come in:
+Wuickjs_runtime focuses on making [quickjs](https://bellard.org/quickjs/) easy to use and does not add any additional features, that's where these projects come in:
 * A more feature-rich (e.g. fetch api support, http based module loader and much more) runtime: [GreenCopperRuntime](https://github.com/HiRoFa/GreenCopperRuntime).
 * The commandline client: [GreenCopperCmd](https://github.com/HiRoFa/GreenCopperCmd).
 
@@ -37,23 +37,23 @@ Please see the [DOCS](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtim
 * Start at the QuickjsRuntimeFacade, it provides an EventQueue which has a thread_local QuickJsRuntimeAdapter
 * All values are copied or abstracted in a JsValueFacades
 * So no need to worry about Garbage collection
-* evaluate script and invoke functions while waiting for results blocking or with async/await  
+* Evaluate script and invoke functions while waiting for results blocking or with async/await  
 * Get Promise result blocking or with async/await
 
 # What works?
 
 ## Script and Modules
 
 * Typescript (via SWC)
-* console (.log/info/debug/trace/error) ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/features/console/index.html))
+* Console (.log/info/debug/trace/error) ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/features/console/index.html))
 * Eval script ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/facades/struct.QuickJsRuntimeFacade.html#method.eval))
 * Create promises in JavaScript which execute async
 * Eval modules ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/facades/struct.QuickJsRuntimeFacade.html#method.eval_module))
 * Load modules (dynamic and static) ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/builder/struct.QuickJsRuntimeBuilder.html#method.script_module_loader))
-* fetch api (impl in [GreenCopperRuntime](https://github.com/HiRoFa/GreenCopperRuntime))
+* Fetch api (impl in [GreenCopperRuntime](https://github.com/HiRoFa/GreenCopperRuntime))
 * setImmediate
 * setTimeout/Interval (and clear)
-* script preprocessing (impls for ifdef/macro's/typescript can be found in [GreenCopperRuntime](https://github.com/HiRoFa/GreenCopperRuntime))
+* Script preprocessing (impls for ifdef/macro's/typescript can be found in [GreenCopperRuntime](https://github.com/HiRoFa/GreenCopperRuntime))
 
 ## Rust-Script interoperability
 
@@ -62,8 +62,8 @@ Please see the [DOCS](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtim
 * Invoke JS functions from rust ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/facades/struct.QuickJsRuntimeFacade.html#method.invoke_function))
 * Pass primitives, objects and arrays from and to rust ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/quickjs_utils/primitives/index.html))
 * Create Classes from rust ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/reflection/struct.Proxy.html))
-* async/await support on eval/call_function/promise resolution ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/values/struct.CachedJsPromiseRef.html#method.get_promise_result))
-* import native Modules (e.g. dynamic loading of rust functions or Proxy classes) ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/builder/struct.QuickJsRuntimeBuilder.html#method.native_module_loader))
+* Async/await support on eval/call_function/promise resolution ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/values/struct.CachedJsPromiseRef.html#method.get_promise_result))
+* Import native Modules (e.g. dynamic loading of rust functions or Proxy classes) ([docs](https://hirofa.github.io/quickjs_es_runtime/quickjs_runtime/builder/struct.QuickJsRuntimeBuilder.html#method.native_module_loader))
 
 # Goals
 
@@ -87,7 +87,7 @@ The fun stuff about QuickJS:
 Cargo.toml
 ```toml
 [dependencies]
-quickjs_runtime = "0.13.1"
+quickjs_runtime = "0.14"
 ```
 
 Here are some quickstarts:

src/quickjs_utils/arrays.rs

@@ -220,17 +220,26 @@ pub mod tests {
         rt.exe_rt_task_in_event_loop(|q_js_rt| {
             let q_ctx = q_js_rt.get_main_realm();
             let arr = create_array_q(q_ctx).ok().unwrap();
+
+            #[cfg(feature = "bellard")]
             assert_eq!(arr.get_ref_count(), 1);
 
             let a = objects::create_object_q(q_ctx).ok().unwrap();
+
+            #[cfg(feature = "bellard")]
             assert_eq!(1, a.get_ref_count());
 
             set_element_q(q_ctx, &arr, 0, &a).ok().unwrap();
+
+            #[cfg(feature = "bellard")]
             assert_eq!(2, a.get_ref_count());
 
-            let a2 = get_element_q(q_ctx, &arr, 0).ok().unwrap();
+            let _a2 = get_element_q(q_ctx, &arr, 0).ok().unwrap();
+
+            #[cfg(feature = "bellard")]
             assert_eq!(3, a.get_ref_count());
-            assert_eq!(3, a2.get_ref_count());
+            #[cfg(feature = "bellard")]
+            assert_eq!(3, _a2.get_ref_count());
         });
     }
 }

src/quickjs_utils/bigints.rs

@@ -28,6 +28,8 @@ pub unsafe fn new_bigint_i64(
 ) -> Result<QuickJsValueAdapter, JsError> {
     let res_val = q::JS_NewBigInt64(context, int);
     let ret = QuickJsValueAdapter::new(context, res_val, false, true, "new_bigint_i64");
+
+    #[cfg(feature = "bellard")]
     assert_eq!(ret.get_ref_count(), 1);
     Ok(ret)
 }
@@ -41,6 +43,8 @@ pub unsafe fn new_bigint_u64(
 ) -> Result<QuickJsValueAdapter, JsError> {
     let res_val = q::JS_NewBigUint64(context, int);
     let ret = QuickJsValueAdapter::new(context, res_val, false, true, "new_bigint_u64");
+
+    #[cfg(feature = "bellard")]
     assert_eq!(ret.get_ref_count(), 1);
     Ok(ret)
 }
@@ -63,6 +67,8 @@ pub unsafe fn new_bigint_str(
     let str_ref = primitives::from_string(context, input_str)?;
     let bigint_ref = functions::invoke_member_function(context, &global_ref, "BigInt", &[str_ref])?;
     let ret = bigint_ref;
+
+    #[cfg(feature = "bellard")]
     assert_eq!(ret.get_ref_count(), 1);
     Ok(ret)
 }

src/quickjs_utils/compile.rs

@@ -295,31 +295,37 @@ pub mod tests {
                 Script::new("test_func_runfail.es", "let abcdef = 1;"),
             );
             let func = func_res.expect("func compile failed");
+            #[cfg(feature = "bellard")]
             assert_eq!(1, func.get_ref_count());
 
             let bytecode: Vec<u8> = to_bytecode(q_ctx.context, &func);
 
+            #[cfg(feature = "bellard")]
             assert_eq!(1, func.get_ref_count());
 
             drop(func);
 
+            #[cfg(feature = "bellard")]
             assert!(!bytecode.is_empty());
 
             let func2_res = from_bytecode(q_ctx.context, &bytecode);
             let func2 = func2_res.expect("could not read bytecode");
             //should fail the second time you run this because abcdef is already defined
 
+            #[cfg(feature = "bellard")]
             assert_eq!(1, func2.get_ref_count());
 
             let run_res1 =
                 run_compiled_function(q_ctx.context, &func2).expect("run 1 failed unexpectedly");
             drop(run_res1);
 
+            #[cfg(feature = "bellard")]
             assert_eq!(1, func2.get_ref_count());
 
             let _run_res2 = run_compiled_function(q_ctx.context, &func2)
                 .expect_err("run 2 succeeded unexpectedly");
 
+            #[cfg(feature = "bellard")]
             assert_eq!(1, func2.get_ref_count());
         });
     }

src/quickjs_utils/functions.rs

@@ -721,32 +721,41 @@ pub mod tests {
                     "this.test = {q: {}}; let global = this; (function(a, b){global.test.a = a; return {a: 1};});",
                 ))
                 .expect("aa");
+            #[cfg(feature = "bellard")]
             assert_eq!(func_ref.get_ref_count(), 1);
 
             let a = objects::create_object_q(q_ctx).ok().unwrap();
             let b = objects::create_object_q(q_ctx).ok().unwrap();
 
+            #[cfg(feature = "bellard")]
             assert_eq!(1, a.get_ref_count());
+            #[cfg(feature = "bellard")]
             assert_eq!(1, b.get_ref_count());
 
             let i_res = call_function_q(q_ctx, &func_ref, &[a.clone(), b.clone()], None)
                 .expect("a");
+
             assert!(i_res.is_object());
+            #[cfg(feature = "bellard")]
             assert_eq!(i_res.get_ref_count(), 1);
-
+            #[cfg(feature = "bellard")]
             assert_eq!(2, a.get_ref_count());
+            #[cfg(feature = "bellard")]
             assert_eq!(1, b.get_ref_count());
 
             let q_ref = q_ctx.eval(Script::new("test_ret_refcount2.es", "test.q;")).expect("get q failed");
+            #[cfg(feature = "bellard")]
             assert_eq!(2, q_ref.get_ref_count());
             let _ = call_function_q(q_ctx, &func_ref, &[primitives::from_i32(123), q_ref], None)
                 .expect("b");
             let q_ref = q_ctx.eval(Script::new("test_ret_refcount2.es", "test.q;")).expect("get q failed");
+            #[cfg(feature = "bellard")]
             assert_eq!(2, q_ref.get_ref_count());
             let _ = call_function_q(q_ctx, &func_ref, &[q_ref, primitives::from_i32(123)], None)
                 .expect("b");
-            let q_ref = q_ctx.eval(Script::new("test_ret_refcount2.es", "test.q;")).expect("get q failed");
-            assert_eq!(3, q_ref.get_ref_count());
+            let _q_ref = q_ctx.eval(Script::new("test_ret_refcount2.es", "test.q;")).expect("get q failed");
+            #[cfg(feature = "bellard")]
+            assert_eq!(3, _q_ref.get_ref_count());
 
             // cleanup
             q_ctx.eval(Script::new("cleanup.es", "this.test = null;")).ok().unwrap();
@@ -835,6 +844,7 @@ pub mod tests {
             .ok()
             .expect("could not create function");
 
+            #[cfg(feature = "bellard")]
             assert_eq!(1, cb_ref.get_ref_count());
 
             cb_ref.label("cb_ref at test_callback");
@@ -844,6 +854,7 @@ pub mod tests {
                 .ok()
                 .expect("could not get function");
 
+            #[cfg(feature = "bellard")]
             assert_eq!(2, func_ref.get_ref_count());
 
             let res = call_function_q(q_ctx, &func_ref, &[cb_ref], None);
@@ -876,9 +887,10 @@ pub mod tests {
             let cb_ref = new_function_q(
                 q_ctx,
                 "cb",
-                |_q_ctx, _this_ref, args| {
+                |_q_ctx, _this_ref, _args| {
                     log::trace!("native callback invoked");
-                    assert_eq!(args[0].get_ref_count(), 3);
+                    #[cfg(feature = "bellard")]
+                    assert_eq!(_args[0].get_ref_count(), 3);
 
                     Ok(primitives::from_i32(983))
                 },

src/quickjs_utils/json.rs

@@ -156,6 +156,8 @@ pub mod tests {
             .ok()
             .unwrap();
             let str_res = json::stringify_q(q_ctx, &obj, None).ok().unwrap();
+
+            #[cfg(feature = "bellard")]
             assert_eq!(str_res.get_ref_count(), 1);
             let json = str_res.to_string().ok().unwrap();
             assert_eq!(json, "{\"a\":532,\"b\":true,\"c\":\"abcdË\"}");

src/quickjs_utils/mod.rs

@@ -173,10 +173,12 @@ pub mod tests {
         rt.exe_rt_task_in_event_loop(|q_js_rt| {
             let q_ctx = q_js_rt.get_main_realm();
 
+            #[cfg(feature = "bellard")]
             let ct = get_global_q(q_ctx).get_ref_count();
             for _ in 0..5 {
-                let global = get_global_q(q_ctx);
-                assert_eq!(global.get_ref_count(), ct);
+                let _global = get_global_q(q_ctx);
+                #[cfg(feature = "bellard")]
+                assert_eq!(_global.get_ref_count(), ct);
             }
         });
     }

src/quickjs_utils/modules.rs

@@ -78,8 +78,33 @@ pub fn set_module_loader(q_js_rt: &QuickJsRuntimeAdapter) {
 
 /// detect if a script is module (contains import or export statements)
 pub fn detect_module(source: &str) -> bool {
-    let cstr = CString::new(source).expect("could not create CString due to null term in source");
-    unsafe { q::JS_DetectModule(cstr.as_ptr(), source.len() as _) != 0 }
+    // own impl since detectmodule in quickjs-ng is broken since 0.7.0
+    // https://github.com/quickjs-ng/quickjs/issues/767
+
+    // Check for static `import` statements
+
+    #[cfg(feature = "quickjs-ng")]
+    {
+        for line in source.lines() {
+            let trimmed = line.trim();
+            if trimmed.starts_with("import ") && !trimmed.contains("(") {
+                return true;
+            }
+            if trimmed.starts_with("export ") {
+                return true;
+            }
+        }
+        false
+    }
+
+    #[cfg(feature = "bellard")]
+    {
+        let cstr =
+            CString::new(source).expect("could not create CString due to null term in source");
+        let res = unsafe { q::JS_DetectModule(cstr.as_ptr(), source.len() as _) };
+        //println!("res for {} = {}", source, res);
+        res != 0
+    }
 }
 
 /// create new Module (JSModuleDef struct) which can be populated with exports after (and from) the init_func
@@ -274,10 +299,11 @@ pub mod tests {
 
     #[test]
     fn test_detect() {
-        assert!(detect_module("import {} from 'foo.es';"));
+        assert!(detect_module("import {} from 'foo.js';"));
         assert!(detect_module("export function a(){};"));
-        assert!(!detect_module("import('foo.es').then((a) = {});"));
+        assert!(!detect_module("//hi"));
         assert!(!detect_module("let a = 1;"));
+        assert!(!detect_module("import('foo.js').then((a) = {});"));
     }
 
     #[test]