fix: resolve broadcast_channel tests and custom_import_logic example

- Add explicit type annotations to broadcast_channel async test methods
- Fix test import paths (use super::BroadcastChannel)
- Replace URL-dependent assert module with simpler colors module
- All tests now pass with --all-features (50 tests)

Author: chaizhenhua

examples/custom_import_logic.rs

@@ -101,8 +101,10 @@ impl ImportProvider for MyImportProvider {
 
 fn main() -> Result<(), rustyscript::Error> {
     let mut import_provider = MyImportProvider::default();
-    import_provider.add_redirect("mod_assert", "https://deno.land/std@0.224.0/assert/mod.ts")?;
-    import_provider.add_static_module("my-module", "export const foo = 1");
+    // Add a redirect for a simple utility module
+    import_provider.add_redirect("colors", "https://deno.land/std@0.224.0/fmt/colors.ts")?;
+    // Add a static module with some test data
+    import_provider.add_static_module("my-module", "export const foo = 1; export const bar = 'test';");
 
     let mut runtime = Runtime::new(RuntimeOptions {
         import_provider: Some(Box::new(import_provider)),
@@ -112,10 +114,17 @@ fn main() -> Result<(), rustyscript::Error> {
     let module = Module::new(
         "custom_imports.js",
         "
-        import { assertEquals } from 'redirect:mod_assert';
-        import { foo } from 'static:my-module';
-        
-        assertEquals(1, foo)
+        import { bold } from 'redirect:colors';
+        import { foo, bar } from 'static:my-module';
+
+        // Test static module imports
+        if (foo !== 1) throw new Error('Expected foo to be 1');
+        if (bar !== 'test') throw new Error('Expected bar to be test');
+
+        // Test redirect module import
+        const text = bold('Hello from custom imports!');
+        console.log(text);
+        console.log('✓ All custom import tests passed!');
         ",
     );
 

src/ext/broadcast_channel/wrapper.rs

@@ -255,7 +255,8 @@ impl Drop for BroadcastChannelWrapper {
 
 #[cfg(test)]
 mod test {
-    use crate::{BroadcastChannel, Runtime, RuntimeOptions};
+    use super::BroadcastChannel;
+    use crate::{Runtime, RuntimeOptions};
 
     #[test]
     fn test_broadcast_channel_send_recv() {
@@ -276,17 +277,16 @@ mod test {
         let tokio_rt = runtime.tokio_runtime();
         tokio_rt.block_on(async {
             // Send from wrapper1
-            wrapper1
-                .send(&mut runtime, "hello from rust")
-                .await
-                .unwrap();
+            let send_result: Result<(), crate::Error> = wrapper1
+                .send::<&str>(&mut runtime, "hello from rust")
+                .await;
+            send_result.unwrap();
 
             // Receive from wrapper2
-            let received: String = wrapper2
-                .recv(&mut runtime, Some(std::time::Duration::from_secs(1)))
-                .await
-                .unwrap()
-                .unwrap();
+            let recv_result: Result<Option<String>, crate::Error> = wrapper2
+                .recv::<String>(&mut runtime, Some(std::time::Duration::from_secs(1)))
+                .await;
+            let received: String = recv_result.unwrap().unwrap();
 
             assert_eq!(received, "hello from rust");
         });
@@ -318,13 +318,16 @@ mod test {
         let tokio_rt = runtime.tokio_runtime();
         tokio_rt.block_on(async {
             // Send to channel_a
-            wrapper_a.send(&mut runtime, "message for a").await.unwrap();
+            let send_result: Result<(), crate::Error> = wrapper_a
+                .send::<&str>(&mut runtime, "message for a")
+                .await;
+            send_result.unwrap();
 
             // wrapper_b should not receive this message (different channel name)
-            let result: Option<String> = wrapper_b
-                .recv(&mut runtime, Some(std::time::Duration::from_millis(100)))
-                .await
-                .unwrap();
+            let recv_result: Result<Option<String>, crate::Error> = wrapper_b
+                .recv::<String>(&mut runtime, Some(std::time::Duration::from_millis(100)))
+                .await;
+            let result: Option<String> = recv_result.unwrap();
 
             assert!(result.is_none());
         });