farmfe_plugin_script 2.0.1

Script compilation plugin of farm.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::sync::Arc;

use farmfe_core::{
  config::script::{DecoratorVersion, ScriptConfig},
  context::CompilationContext,
  module::ModuleId,
  plugin::PluginProcessModuleHookParam,
  swc_common::{comments::SingleThreadedComments, Globals, Mark, SourceMap},
  swc_ecma_ast::Program,
};
use farmfe_toolkit::{
  script::swc_try_with::try_with,
  swc_ecma_transforms::{
    proposals::{decorator_2022_03::decorator_2022_03, decorators},
    typescript::{tsx, typescript, Config as TsConfig, ImportsNotUsedAsValues, TsxConfig},
  },
  swc_ecma_transforms_base::helpers::inject_helpers,
  swc_ecma_visit::VisitMutWith,
};

fn default_config(script: &ScriptConfig, module_id: &ModuleId) -> TsConfig {
  let import_not_used_as_values = if script.import_not_used_as_values.is_preserved(module_id) {
    ImportsNotUsedAsValues::Preserve
  } else {
    ImportsNotUsedAsValues::Remove
  };
  TsConfig {
    // verbatim_module_syntax: script.verbatim_module_syntax,
    import_not_used_as_values,
    ..Default::default()
  }
}

pub fn strip_typescript(
  param: &mut PluginProcessModuleHookParam,
  cm: &Arc<SourceMap>,
  globals: &Globals,
  context: &Arc<CompilationContext>,
) -> farmfe_core::error::Result<()> {
  try_with(cm.clone(), globals, || {
    let top_level_mark = Mark::from_u32(param.meta.as_script().top_level_mark);
    let unresolved_mark = Mark::from_u32(param.meta.as_script().unresolved_mark);
    let ast = param.meta.as_script_mut().take_ast();
    let mut program = Program::Module(ast);

    match param.module_type {
      farmfe_core::module::ModuleType::Js => {}
      farmfe_core::module::ModuleType::Jsx => {
        // Do nothing, jsx should be handled by other plugins
      }
      farmfe_core::module::ModuleType::Ts => {
        program.mutate(&mut typescript(
          default_config(&context.config.script, param.module_id),
          unresolved_mark,
          top_level_mark,
        ));
      }
      farmfe_core::module::ModuleType::Tsx => {
        let comments: SingleThreadedComments = param.meta.as_script().comments.clone().into();
        // TODO make it configurable
        program.mutate(&mut tsx(
          cm.clone(),
          default_config(&context.config.script, param.module_id),
          TsxConfig::default(),
          comments,
          unresolved_mark,
          top_level_mark,
        ));
        program.mutate(&mut typescript(
          default_config(&context.config.script, param.module_id),
          unresolved_mark,
          top_level_mark,
        ));
      }
      _ => {}
    }

    param.meta.as_script_mut().set_ast(program.expect_module());
  })
}

pub fn transform_decorators(
  param: &mut PluginProcessModuleHookParam,
  cm: &Arc<SourceMap>,
  globals: &Globals,
  context: &Arc<CompilationContext>,
) -> farmfe_core::error::Result<()> {
  let config = &context.config.script.decorators;
  let is_included = config
    .includes
    .iter()
    .any(|r| r.is_match(&param.module_id.to_string()));
  let is_excluded = config
    .excludes
    .iter()
    .any(|r| r.is_match(&param.module_id.to_string()));

  if is_included || !is_excluded {
    try_with(cm.clone(), globals, || {
      let mut ast = Program::Module(param.meta.as_script_mut().take_ast());

      match config.decorator_version.clone().unwrap_or_default() {
        DecoratorVersion::V202112 => {
          ast.mutate(&mut decorators(decorators::Config {
            legacy: config.legacy_decorator,
            emit_metadata: config.decorator_metadata,
            ..Default::default()
          }));
        }
        DecoratorVersion::V202203 => ast.mutate(&mut decorator_2022_03()),
      }

      let unresolved_mark = Mark::from_u32(param.meta.as_script().unresolved_mark);
      ast.visit_mut_with(&mut inject_helpers(unresolved_mark));

      param.meta.as_script_mut().set_ast(ast.expect_module());
    })?;
  }

  Ok(())
}