feat(graalvm): add support for MessageChannel

feat: add `MessageChannel` interface and basic impl
feat: add `MessagePort` interface and basic impl
test: add initial tests for channel messaging
test: add `MessageChannel` and `MessagePort` to common minimum
chore: re-pin api for `graalvm` module

Fixes and closes #1317

Relates-to: #1317
Signed-off-by: Sam Gammon <[email protected]>

Author: sgammon

crates/js/src/lib.rs

@@ -18,6 +18,11 @@ use diag::{DiagnosticBuilder, create_diagnostic, report_diagnostic};
 use java_native::jni;
 use jni::JNIEnv;
 use jni::objects::{JClass, JString};
+use jni::sys::jboolean;
+use oxc::codegen::CodegenOptions;
+use oxc::parser::ParseOptions;
+use oxc::span::SourceType;
+use oxc::transformer::TransformOptions;
 
 /// Code generation tools for JavaScript; interoperates with `parser` and other exposed modules.
 mod codegen;
@@ -31,12 +36,43 @@ pub fn precompile<'a>(
   _class: JClass<'a>,
   name: JString<'a>,
   code: JString<'a>,
+  typescript: jboolean,
+  jsx: jboolean,
+  esm: jboolean,
 ) -> JString<'a> {
   let str = env.get_string(&code).unwrap();
   let code = str.to_str().to_string();
   let filename = env.get_string(&name).unwrap().to_str().to_string();
-  let result = codegen::lower_into(GeneratorOptions::default(), filename, code.as_str());
+  let default_options = GeneratorOptions::default();
+  let source_type = if typescript == jni::sys::JNI_TRUE {
+    if jsx == jni::sys::JNI_TRUE {
+      Some(SourceType::tsx())
+    } else {
+      Some(SourceType::ts())
+    }
+  } else {
+    if jsx == jni::sys::JNI_TRUE {
+      Some(SourceType::jsx())
+    } else {
+      if esm == jni::sys::JNI_TRUE {
+        Some(SourceType::mjs())
+      } else {
+        Some(SourceType::cjs())
+      }
+    }
+  };
+  let generatorOptions = GeneratorOptions {
+    source_type,
+    parser: Some(ParseOptions::default()),
+    codegen: Some(CodegenOptions::default()),
+    transform: Some(TransformOptions::default()),
+    ..default_options
+  };
+
+  // fire the precompiler
+  let result = codegen::lower_into(generatorOptions, filename, code.as_str());
 
+  // process errors, which may be non-fatal; such errors are raised as static diagnostics.
   match result {
     Ok(output) => env.new_string(output.code).unwrap(),
 

packages/graalvm-js/api/graalvm-js.api

@@ -54,14 +54,18 @@ public class elide/runtime/lang/javascript/JSRealmPatcher {
 public final class elide/runtime/lang/javascript/JavaScriptCompilerConfig : elide/runtime/precompiler/Precompiler$Configuration {
 	public static final field Companion Lelide/runtime/lang/javascript/JavaScriptCompilerConfig$Companion;
 	public fun <init> ()V
-	public fun <init> (Z)V
-	public synthetic fun <init> (ZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public fun <init> (ZZZ)V
+	public synthetic fun <init> (ZZZILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun component1 ()Z
-	public final fun copy (Z)Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;
-	public static synthetic fun copy$default (Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;ZILjava/lang/Object;)Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;
+	public final fun component2 ()Z
+	public final fun component3 ()Z
+	public final fun copy (ZZZ)Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;
+	public static synthetic fun copy$default (Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;ZZZILjava/lang/Object;)Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;
 	public fun equals (Ljava/lang/Object;)Z
 	public static final fun getDEFAULT ()Lelide/runtime/lang/javascript/JavaScriptCompilerConfig;
+	public final fun getJsx ()Z
 	public final fun getSourceMaps ()Z
+	public final fun getTypescript ()Z
 	public fun hashCode ()I
 	public fun toString ()Ljava/lang/String;
 }

packages/graalvm-js/src/main/kotlin/elide/runtime/lang/javascript/JavaScriptCompilerConfig.kt

@@ -16,9 +16,17 @@ import elide.runtime.precompiler.Precompiler
 
 /**
  * ## Java Script Compiler Config
+ *
+ * @property sourceMaps Whether to generate source maps.
+ * @property jsx Whether to support JSX.
+ * @property esm Whether to support ECMAScript modules.
+ * @property typescript Whether to support TypeScript.
  */
 public data class JavaScriptCompilerConfig(
   val sourceMaps: Boolean = true,
+  val jsx: Boolean = true,
+  val esm: Boolean = true,
+  val typescript: Boolean = true,
 ) : Precompiler.Configuration {
   public companion object {
     /** Default JavaScript compiler configuration. */

packages/graalvm-js/src/main/kotlin/elide/runtime/lang/javascript/JavaScriptPrecompiler.kt

@@ -12,8 +12,6 @@
  */
 package elide.runtime.lang.javascript
 
-import org.graalvm.nativeimage.ImageInfo
-import kotlinx.atomicfu.atomic
 import elide.annotations.API
 import elide.runtime.core.lib.NativeLibraries
 import elide.runtime.diag.Diagnostics
@@ -52,7 +50,7 @@ public object JavaScriptPrecompiler : Precompiler.SourcePrecompiler<JavaScriptCo
   @Suppress("TooGenericExceptionCaught")
   override fun invoke(req: PrecompileSourceRequest<JavaScriptCompilerConfig>, input: String): String? = try {
     initialize()
-    precompile(req.source.name, input).also {
+    precompile(req.config, req.source.name, input).also {
       // after running the precompiler, consume all matching diagnostics (if present), and throw them back to the caller
       if (Diagnostics.dirty(LANG_TAG_JS)) Diagnostics.query(LANG_TAG_JS, TOOL_PRECOMPILER, true).let { diag ->
         PrecompilerNotice.Companion.from(DiagnosticsContainer.Companion.from(diag))
@@ -62,17 +60,30 @@ public object JavaScriptPrecompiler : Precompiler.SourcePrecompiler<JavaScriptCo
     throw PrecompilerError("Precompile failed: ${err.javaClass.simpleName} ${err.message}", err)
   }
 
+  // Precompile with assigned configuration.
+  private fun precompile(config: JavaScriptCompilerConfig, name: String, input: String): String? {
+    val ts = config.typescript
+    val jsx = config.jsx
+    val esm = config.esm || name.endsWith(".mjs")
+    return precompile(name, input, ts, jsx, esm)
+  }
+
   /**
-   * ## Precompile JavaScript
+   * ## Precompile JavaScript/TypeScript
    *
    * This method accepts code in the form of JSX, TSX, TypeScript, or JavaScript, and will act to parse it using the
    * native parser, and then lower it into compliant ECMA code which is runnable by Elide.
    *
    * @param name Filename for the code provided herein
    * @param code Code contents from the file in question
+   * @param ts Whether the code is expected to support TypeScript types or not
+   * @param jsx Whether the code is expected to support JSX/TSX or not
+   * @param esm Whether the code is expected to be an ES Module or not
    * @return Lowered source-code which should be used instead
    */
-  @JvmStatic @JvmName("precompile") private external fun precompile(name: String, code: String): String?
+  @JvmStatic
+  @JvmName("precompile")
+  private external fun precompile(name: String, code: String, ts: Boolean, jsx: Boolean, esm: Boolean): String?
 
   /** Provider for the [JavaScriptPrecompiler]. */
   public class Provider : Precompiler.Provider<JavaScriptPrecompiler> {