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

use std::{path::PathBuf, sync::Arc};

use farmfe_core::{
  context::CompilationContext,
  module::{Module, ModuleId},
  plugin::{
    Plugin, PluginAnalyzeDepsHookParam, PluginAnalyzeDepsHookResultEntry,
    PluginFinalizeModuleHookParam, PluginHookContext, PluginLoadHookParam, PluginParseHookParam,
    PluginProcessModuleHookParam,
  },
  HashMap,
};

pub fn build_module_deps(
  path: PathBuf,
  base: PathBuf,
) -> (Module, Vec<PluginAnalyzeDepsHookResultEntry>) {
  let config = Default::default();
  let context = Arc::new(CompilationContext::new(config, vec![]).unwrap());
  let script_plugin = farmfe_plugin_script::FarmPluginScript::new(&context.config);
  let script_meta_features =
    farmfe_plugin_script_meta::FarmPluginScriptMetaFeatures::new(&context.config);

  let hook_context = PluginHookContext {
    caller: None,
    meta: HashMap::default(),
  };

  let load_result = script_plugin
    .load(
      &PluginLoadHookParam {
        resolved_path: &path.to_string_lossy(),
        query: vec![],
        meta: HashMap::default(),
        module_id: path.to_string_lossy().to_string(),
      },
      &context,
      &hook_context,
    )
    .unwrap()
    .unwrap();

  let mut parse_result = script_plugin
    .parse(
      &PluginParseHookParam {
        module_id: ModuleId::new(&path.to_string_lossy(), "", base.to_str().unwrap()),
        resolved_path: path.to_string_lossy().to_string(),
        query: vec![],
        module_type: load_result.module_type.clone(),
        content: Arc::new(load_result.content.clone()),
      },
      &context,
      &hook_context,
    )
    .unwrap()
    .unwrap();

  let mut module = Module::new(ModuleId::new(
    &path.to_string_lossy(),
    "",
    base.to_str().unwrap(),
  ));

  module.module_type = load_result.module_type;

  let mut process_module_param = PluginProcessModuleHookParam {
    module_id: &module.id,
    module_type: &module.module_type,
    meta: &mut parse_result,
    content: &mut Arc::new(load_result.content),
    source_map_chain: &mut vec![],
  };
  script_plugin
    .process_module(&mut process_module_param, &context)
    .unwrap();

  module.meta = Box::new(parse_result);

  let mut analyze_deps_param = PluginAnalyzeDepsHookParam {
    module: &module,
    deps: vec![],
  };

  script_plugin
    .analyze_deps(&mut analyze_deps_param, &context)
    .unwrap();

  let mut deps = analyze_deps_param.deps;

  script_plugin
    .finalize_module(
      &mut PluginFinalizeModuleHookParam {
        module: &mut module,
        deps: &mut deps,
      },
      &context,
    )
    .unwrap();
  script_meta_features
    .finalize_module(
      &mut PluginFinalizeModuleHookParam {
        module: &mut module,
        deps: &mut deps,
      },
      &context,
    )
    .unwrap();

  (module, deps)
}

pub fn build_module(path: PathBuf, base: PathBuf) -> Module {
  build_module_deps(path, base).0
}