denoland-deno/cli/tools/bundle.rs

// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.

use std::path::PathBuf;

use deno_core::error::AnyError;
use deno_graph::Module;
use deno_runtime::colors;

use crate::args::BundleFlags;
use crate::args::CliOptions;
use crate::args::Flags;
use crate::args::TsConfigType;
use crate::factory::CliFactory;
use crate::factory::CliFactoryBuilder;
use crate::graph_util::error_for_any_npm_specifier;
use crate::util;
use crate::util::display;

pub async fn bundle(
  flags: Flags,
  bundle_flags: BundleFlags,
) -> Result<(), AnyError> {
  log::info!(
    "{} \"deno bundle\" is deprecated and will be removed in the future.",
    colors::yellow("Warning"),
  );
  log::info!(
    "Use alternative bundlers like \"deno_emit\", \"esbuild\" or \"rollup\" instead."
  );

  if let Some(watch_flags) = &bundle_flags.watch {
    util::file_watcher::watch_func(
      flags,
      util::file_watcher::PrintConfig {
        job_name: "Bundle".to_string(),
        clear_screen: !watch_flags.no_clear_screen,
      },
      move |flags, sender, _changed_paths| {
        let bundle_flags = bundle_flags.clone();
        Ok(async move {
          let factory = CliFactoryBuilder::new()
            .with_watcher(sender.clone())
            .build_from_flags(flags)
            .await?;
          let cli_options = factory.cli_options();
          let _ = sender.send(cli_options.watch_paths());
          bundle_action(factory, &bundle_flags).await?;

          Ok(())
        })
      },
    )
    .await?;
  } else {
    let factory = CliFactory::from_flags(flags).await?;
    bundle_action(factory, &bundle_flags).await?;
  }

  Ok(())
}

async fn bundle_action(
  factory: CliFactory,
  bundle_flags: &BundleFlags,
) -> Result<(), AnyError> {
  let cli_options = factory.cli_options();
  let module_specifier = cli_options.resolve_main_module()?;
  log::debug!(">>>>> bundle START");
  let module_graph_builder = factory.module_graph_builder().await?;
  let cli_options = factory.cli_options();

  let graph = module_graph_builder
    .create_graph_and_maybe_check(vec![module_specifier.clone()])
    .await?;

  let mut paths_to_watch: Vec<PathBuf> = graph
    .specifiers()
    .filter_map(|(_, r)| {
      r.ok().and_then(|module| match module {
        Module::Esm(m) => m.specifier.to_file_path().ok(),
        Module::Json(m) => m.specifier.to_file_path().ok(),
        // nothing to watch
        Module::Node(_) | Module::Npm(_) | Module::External(_) => None,
      })
    })
    .collect();

  if let Ok(Some(import_map_path)) = cli_options
    .resolve_import_map_specifier()
    .map(|ms| ms.and_then(|ref s| s.to_file_path().ok()))
  {
    paths_to_watch.push(import_map_path);
  }

  // at the moment, we don't support npm specifiers in deno bundle, so show an error
  error_for_any_npm_specifier(&graph)?;

  let bundle_output = bundle_module_graph(graph.as_ref(), cli_options)?;
  log::debug!(">>>>> bundle END");
  let out_file = &bundle_flags.out_file;

  if let Some(out_file) = out_file {
    let output_bytes = bundle_output.code.as_bytes();
    let output_len = output_bytes.len();
    util::fs::write_file(out_file, output_bytes, 0o644)?;
    log::info!(
      "{} {:?} ({})",
      colors::green("Emit"),
      out_file,
      colors::gray(display::human_size(output_len as f64))
    );
    if let Some(bundle_map) = bundle_output.maybe_map {
      let map_bytes = bundle_map.as_bytes();
      let map_len = map_bytes.len();
      let ext = if let Some(curr_ext) = out_file.extension() {
        format!("{}.map", curr_ext.to_string_lossy())
      } else {
        "map".to_string()
      };
      let map_out_file = out_file.with_extension(ext);
      util::fs::write_file(&map_out_file, map_bytes, 0o644)?;
      log::info!(
        "{} {:?} ({})",
        colors::green("Emit"),
        map_out_file,
        colors::gray(display::human_size(map_len as f64))
      );
    }
  } else {
    println!("{}", bundle_output.code);
  }
  Ok(())
}

fn bundle_module_graph(
  graph: &deno_graph::ModuleGraph,
  cli_options: &CliOptions,
) -> Result<deno_emit::BundleEmit, AnyError> {
  log::info!("{} {}", colors::green("Bundle"), graph.roots[0]);

  let ts_config_result =
    cli_options.resolve_ts_config_for_emit(TsConfigType::Bundle)?;
  if !cli_options.type_check_mode().is_true() {
    if let Some(ignored_options) = ts_config_result.maybe_ignored_options {
      log::warn!("{}", ignored_options);
    }
  }

  deno_emit::bundle_graph(
    graph,
    deno_emit::BundleOptions {
      bundle_type: deno_emit::BundleType::Module,
      emit_options: ts_config_result.ts_config.into(),
      emit_ignore_directives: true,
    },
  )
}