Merge branch 'main' into f_cache_env_file

Author: marshallwalker

cli/factory.rs

@@ -306,7 +306,6 @@ struct CliFactoryServices {
   blob_store: Deferred<Arc<BlobStore>>,
   caches: Deferred<Arc<Caches>>,
   cjs_module_export_analyzer: Deferred<Arc<CliCjsModuleExportAnalyzer>>,
-  cjs_tracker: Deferred<Arc<CliCjsTracker>>,
   cli_options: Deferred<Arc<CliOptions>>,
   code_cache: Deferred<Arc<CodeCache>>,
   deno_dir_path_provider: Deferred<Arc<CliDenoDirPathProvider>>,
@@ -1117,20 +1116,7 @@ impl CliFactory {
   }
 
   pub fn cjs_tracker(&self) -> Result<&Arc<CliCjsTracker>, AnyError> {
-    self.services.cjs_tracker.get_or_try_init(|| {
-      let options = self.cli_options()?;
-      Ok(Arc::new(CliCjsTracker::new(
-        self.in_npm_pkg_checker()?.clone(),
-        self.pkg_json_resolver()?.clone(),
-        if options.is_node_main() || options.unstable_detect_cjs() {
-          IsCjsResolutionMode::ImplicitTypeCommonJs
-        } else if options.detect_cjs() {
-          IsCjsResolutionMode::ExplicitTypeCommonJs
-        } else {
-          IsCjsResolutionMode::Disabled
-        },
-      )))
-    })
+    self.resolver_factory()?.cjs_tracker()
   }
 
   pub fn permission_desc_parser(
@@ -1396,9 +1382,19 @@ impl CliFactory {
 
   pub fn resolver_factory(&self) -> Result<&Arc<CliResolverFactory>, AnyError> {
     self.services.resolver_factory.get_or_try_init(|| {
+      let options = self.cli_options()?;
       Ok(Arc::new(CliResolverFactory::new(
         self.workspace_factory()?.clone(),
         ResolverFactoryOptions {
+          is_cjs_resolution_mode: if options.is_node_main()
+            || options.unstable_detect_cjs()
+          {
+            IsCjsResolutionMode::ImplicitTypeCommonJs
+          } else if options.detect_cjs() {
+            IsCjsResolutionMode::ExplicitTypeCommonJs
+          } else {
+            IsCjsResolutionMode::Disabled
+          },
           node_resolver_options: NodeResolverOptions {
             conditions_from_resolution_mode: Default::default(),
             typescript_version: Some(
@@ -1411,7 +1407,7 @@ impl CliFactory {
           node_resolution_cache: Some(Arc::new(NodeResolutionThreadLocalCache)),
           npm_system_info: self.flags.subcommand.npm_system_info(),
           specified_import_map: Some(Box::new(CliSpecifiedImportMapProvider {
-            cli_options: self.cli_options()?.clone(),
+            cli_options: options.clone(),
             eszip_module_loader_provider: self
               .eszip_module_loader_provider()?
               .clone(),

cli/main.rs

@@ -686,7 +686,8 @@ fn wait_for_start(
         Serving,
       }
 
-      let buf = deno_core::serde_json::to_vec(&Event::Serving).unwrap();
+      let mut buf = deno_core::serde_json::to_vec(&Event::Serving).unwrap();
+      buf.push(b'\n');
       let _ = tx.write_all(&buf).await;
     });
 

ext/node/polyfills/_process/streams.mjs

@@ -23,6 +23,7 @@ import {
 import { Duplex, Readable, Writable } from "node:stream";
 import * as io from "ext:deno_io/12_io.js";
 import { guessHandleType } from "ext:deno_node/internal_binding/util.ts";
+import { op_bootstrap_color_depth } from "ext:core/ops";
 
 // https://github.com/nodejs/node/blob/00738314828074243c9a52a228ab4c68b04259ef/lib/internal/bootstrap/switches/is_main_thread.js#L41
 export function createWritableStdioStream(writer, name, warmup = false) {
@@ -103,6 +104,13 @@ export function createWritableStdioStream(writer, name, warmup = false) {
       value: () =>
         writer?.isTerminal() ? ObjectValues(Deno.consoleSize?.()) : undefined,
     },
+    getColorDepth: {
+      __proto__: null,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: () => op_bootstrap_color_depth(),
+    },
   });
 
   // If we're warming up, create a stdout/stderr stream that assumes a terminal (the most likely case).

resolvers/deno/cjs.rs

@@ -10,6 +10,10 @@ use url::Url;
 
 use crate::sync::MaybeDashMap;
 
+#[allow(clippy::disallowed_types)]
+pub type CjsTrackerRc<TInNpmPackageChecker, TSys> =
+  crate::sync::MaybeArc<CjsTracker<TInNpmPackageChecker, TSys>>;
+
 /// Keeps track of what module specifiers were resolved as CJS.
 ///
 /// Modules that are `.js`, `.ts`, `.jsx`, and `tsx` are only known to
@@ -135,13 +139,14 @@ impl<TInNpmPackageChecker: InNpmPackageChecker, TSys: FsRead>
   }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub enum IsCjsResolutionMode {
   /// Requires an explicit `"type": "commonjs"` in the package.json.
   ExplicitTypeCommonJs,
   /// Implicitly uses `"type": "commonjs"` if no `"type"` is specified.
   ImplicitTypeCommonJs,
   /// Does not respect `"type": "commonjs"` and always treats ambiguous files as ESM.
+  #[default]
   Disabled,
 }
 

resolvers/deno/factory.rs

@@ -47,6 +47,9 @@ use sys_traits::ThreadSleep;
 use thiserror::Error;
 use url::Url;
 
+use crate::cjs::CjsTracker;
+use crate::cjs::CjsTrackerRc;
+use crate::cjs::IsCjsResolutionMode;
 use crate::npm::managed::ManagedInNpmPkgCheckerCreateOptions;
 use crate::npm::managed::ManagedNpmResolverCreateOptions;
 use crate::npm::managed::NpmResolutionCellRc;
@@ -590,6 +593,7 @@ impl<TSys: WorkspaceFactorySys> WorkspaceFactory<TSys> {
 
 #[derive(Debug, Default)]
 pub struct ResolverFactoryOptions {
+  pub is_cjs_resolution_mode: IsCjsResolutionMode,
   pub npm_system_info: NpmSystemInfo,
   pub node_resolver_options: NodeResolverOptions,
   pub node_resolution_cache: Option<node_resolver::NodeResolutionCacheRc>,
@@ -604,6 +608,7 @@ pub struct ResolverFactoryOptions {
 pub struct ResolverFactory<TSys: WorkspaceFactorySys> {
   options: ResolverFactoryOptions,
   sys: NodeResolutionSys<TSys>,
+  cjs_tracker: Deferred<CjsTrackerRc<DenoInNpmPackageChecker, TSys>>,
   deno_resolver: async_once_cell::OnceCell<DefaultDenoResolverRc<TSys>>,
   in_npm_package_checker: Deferred<DenoInNpmPackageChecker>,
   node_resolver: Deferred<
@@ -639,6 +644,7 @@ impl<TSys: WorkspaceFactorySys> ResolverFactory<TSys> {
         workspace_factory.sys.clone(),
         options.node_resolution_cache.clone(),
       ),
+      cjs_tracker: Default::default(),
       deno_resolver: Default::default(),
       in_npm_package_checker: Default::default(),
       node_resolver: Default::default(),
@@ -685,6 +691,18 @@ impl<TSys: WorkspaceFactorySys> ResolverFactory<TSys> {
       .await
   }
 
+  pub fn cjs_tracker(
+    &self,
+  ) -> Result<&CjsTrackerRc<DenoInNpmPackageChecker, TSys>, anyhow::Error> {
+    self.cjs_tracker.get_or_try_init(|| {
+      Ok(new_rc(CjsTracker::new(
+        self.in_npm_package_checker()?.clone(),
+        self.pkg_json_resolver().clone(),
+        self.options.is_cjs_resolution_mode,
+      )))
+    })
+  }
+
   pub fn in_npm_package_checker(
     &self,
   ) -> Result<&DenoInNpmPackageChecker, anyhow::Error> {

resolvers/deno/lib.rs

@@ -14,10 +14,12 @@ use deno_semver::npm::NpmPackageReqReference;
 use node_resolver::errors::NodeResolveError;
 use node_resolver::errors::PackageSubpathResolveError;
 use node_resolver::errors::UnknownBuiltInNodeModuleError;
+pub use node_resolver::DenoIsBuiltInNodeModuleChecker;
 use node_resolver::InNpmPackageChecker;
 use node_resolver::IsBuiltInNodeModuleChecker;
 use node_resolver::NodeResolution;
 use node_resolver::NodeResolutionKind;
+pub use node_resolver::NodeResolverOptions;
 use node_resolver::NodeResolverRc;
 use node_resolver::NpmPackageFolderResolver;
 use node_resolver::ResolutionMode;
@@ -185,7 +187,7 @@ pub type DenoResolverRc<
 /// used by the Deno CLI.
 pub type DefaultDenoResolverRc<TSys> = DenoResolverRc<
   npm::DenoInNpmPackageChecker,
-  node_resolver::DenoIsBuiltInNodeModuleChecker,
+  DenoIsBuiltInNodeModuleChecker,
   npm::NpmResolver<TSys>,
   TSys,
 >;

tests/specs/run/unconfigured/main.out

@@ -1,4 +1,5 @@
 true
 hello world
 EVENT: "Serving"
+
 [Object: null prototype] { success: true, code: 0, signal: null }

tests/unit_node/process_test.ts

@@ -657,6 +657,7 @@ Deno.test({
     const consoleSize = isTTY ? Deno.consoleSize() : undefined;
     assertEquals(process.stdout.columns, consoleSize?.columns);
     assertEquals(process.stdout.rows, consoleSize?.rows);
+    assert([1, 4, 8, 24].includes(process.stdout.getColorDepth()));
     assertEquals(
       `${process.stdout.getWindowSize()}`,
       `${consoleSize && [consoleSize.columns, consoleSize.rows]}`,