feat(runtime): Implement classic workers

cli/main.rs

@@ -116,6 +116,7 @@ fn create_web_worker_callback(
       create_web_worker_cb,
       js_error_create_fn: Some(js_error_create_fn),
       use_deno_namespace: args.use_deno_namespace,
+      worker_type: args.worker_type,
       maybe_inspector_server,
       runtime_version: version::deno(),
       ts_version: version::TYPESCRIPT.to_string(),

extensions/fetch/lib.rs

@@ -54,7 +54,9 @@ use tokio::sync::mpsc;
 use tokio_stream::wrappers::ReceiverStream;
 use tokio_util::io::StreamReader;
 
-pub use reqwest; // Re-export reqwest
+// Re-export reqwest and data_url
+pub use data_url;
+pub use reqwest;
 
 pub fn init<P: FetchPermissions + 'static>(
   user_agent: String,

runtime/errors.rs

@@ -159,6 +159,9 @@ pub fn get_error_class_name(e: &AnyError) -> Option<&'static str> {
     .or_else(|| deno_webgpu::error::get_error_class_name(e))
     .or_else(|| deno_web::get_error_class_name(e))
     .or_else(|| deno_webstorage::get_not_supported_error_class_name(e))
+    .or_else(|| {
+      crate::ops::web_worker::get_dom_exception_network_error_class_name(e)
+    })
     .or_else(|| {
       e.downcast_ref::<dlopen::Error>()
         .map(get_dlopen_error_class)

runtime/js/11_workers.js

@@ -7,7 +7,6 @@
     ArrayIsArray,
     ArrayPrototypeMap,
     Error,
-    Uint8Array,
     StringPrototypeStartsWith,
     String,
     SymbolIterator,
@@ -28,6 +27,7 @@
     useDenoNamespace,
     permissions,
     name,
+    workerType,
   ) {
     return core.opSync("op_create_worker", {
       hasSourceCode,
@@ -36,6 +36,7 @@
       sourceCode,
       specifier,
       useDenoNamespace,
+      workerType,
     });
   }
 
@@ -173,27 +174,34 @@
         }
       }
 
-      if (type !== "module") {
-        throw new Error(
-          'Not yet implemented: only "module" type workers are supported',
+      const workerType = String(type);
+      if (workerType !== "classic" && workerType !== "module") {
+        throw new TypeError(
+          `The provided value '${workerType}' is not a valid enum value of type WorkerType.`,
         );
       }
 
-      this.#name = name;
-      const hasSourceCode = false;
-      const sourceCode = core.decode(new Uint8Array());
-
       if (
         StringPrototypeStartsWith(specifier, "./") ||
         StringPrototypeStartsWith(specifier, "../") ||
-        StringPrototypeStartsWith(specifier, "/") || type == "classic"
+        StringPrototypeStartsWith(specifier, "/") || workerType === "classic"
       ) {
         const baseUrl = getLocationHref();
         if (baseUrl != null) {
           specifier = new URL(specifier, baseUrl).href;
         }
       }
 
+      this.#name = name;
+      let hasSourceCode, sourceCode;
+      if (workerType === "classic") {
+        hasSourceCode = true;
+        sourceCode = `importScripts("#");`;
+      } else {
+        hasSourceCode = false;
+        sourceCode = "";
+      }
+
       const id = createWorker(
         specifier,
         hasSourceCode,
@@ -203,6 +211,7 @@
           ? null
           : parsePermissions(workerDenoAttributes.permissions),
         options?.name,
+        workerType,
       );
       this.#id = id;
       this.#pollControl();

runtime/js/99_main.js

@@ -8,6 +8,7 @@ delete Object.prototype.__proto__;
 ((window) => {
   const core = Deno.core;
   const {
+    ArrayPrototypeMap,
     Error,
     FunctionPrototypeCall,
     FunctionPrototypeBind,
@@ -161,6 +162,44 @@ delete Object.prototype.__proto__;
     }
   }
 
+  let loadedMainWorkerScript = false;
+
+  function importScripts(...urls) {
+    if (core.opSync("op_worker_get_type") === "module") {
+      throw new TypeError("Can't import scripts in a module worker.");
+    }
+
+    const baseUrl = location.getLocationHref();
+    const parsedUrls = ArrayPrototypeMap(urls, (scriptUrl) => {
+      try {
+        return new url.URL(scriptUrl, baseUrl ?? undefined).href;
+      } catch {
+        throw new domException.DOMException(
+          "Failed to parse URL.",
+          "SyntaxError",
+        );
+      }
+    });
+
+    // A classic worker's main script has looser MIME type checks than any
+    // imported scripts, so we use `loadedMainWorkerScript` to distinguish them.
+    // TODO(andreubotella) Refactor worker creation so the main script isn't
+    // loaded with `importScripts()`.
+    const scripts = core.opSync(
+      "op_worker_sync_fetch",
+      parsedUrls,
+      !loadedMainWorkerScript,
+    );
+    loadedMainWorkerScript = true;
+
+    for (const { url, script } of scripts) {
+      const err = core.evalContext(script, url)[1];
+      if (err !== null) {
+        throw err.thrown;
+      }
+    }
+  }
+
   function opMainModule() {
     return core.opSync("op_main_module");
   }
@@ -233,6 +272,12 @@ delete Object.prototype.__proto__;
         return new domException.DOMException(msg, "InvalidCharacterError");
       },
     );
+    core.registerErrorBuilder(
+      "DOMExceptionNetworkError",
+      function DOMExceptionNetworkError(msg) {
+        return new domException.DOMException(msg, "NetworkError");
+      },
+    );
   }
 
   class Navigator {
@@ -570,6 +615,14 @@ delete Object.prototype.__proto__;
     const { unstableFlag, pid, noColor, args, location: locationHref } =
       runtimeOptions;
 
+    if (unstableFlag) {
+      ObjectDefineProperty(
+        globalThis,
+        "importScripts",
+        util.writable(importScripts),
+      );
+    }
+
     location.setLocationHref(locationHref);
     registerErrors();
 

runtime/ops/web_worker.rs

@@ -1,6 +1,9 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
+mod sync_fetch;
+
 use crate::web_worker::WebWorkerInternalHandle;
+use crate::web_worker::WebWorkerType;
 use crate::web_worker::WorkerControlEvent;
 use deno_core::error::generic_error;
 use deno_core::error::AnyError;
@@ -13,6 +16,10 @@ use deno_web::JsMessageData;
 use std::cell::RefCell;
 use std::rc::Rc;
 
+use self::sync_fetch::op_worker_sync_fetch;
+
+pub use sync_fetch::get_dom_exception_network_error_class_name;
+
 pub fn init() -> Extension {
   Extension::builder()
     .ops(vec![
@@ -25,6 +32,8 @@ pub fn init() -> Extension {
         "op_worker_unhandled_error",
         op_sync(op_worker_unhandled_error),
       ),
+      ("op_worker_get_type", op_sync(op_worker_get_type)),
+      ("op_worker_sync_fetch", op_sync(op_worker_sync_fetch)),
     ])
     .build()
 }
@@ -79,3 +88,12 @@ fn op_worker_unhandled_error(
     .expect("Failed to propagate error event to parent worker");
   Ok(())
 }
+
+fn op_worker_get_type(
+  state: &mut OpState,
+  _: (),
+  _: (),
+) -> Result<WebWorkerType, AnyError> {
+  let handle = state.borrow::<WebWorkerInternalHandle>().clone();
+  Ok(handle.worker_type)
+}