farmfe_core 2.1.0

Core types and data structures for 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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use serde::{Deserialize, Serialize};

use crate::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash, Default)]
pub enum TargetEnv {
  #[serde(rename = "browser")]
  #[default]
  Browser,
  #[serde(rename = "node")]
  Node,
  #[serde(rename = "library")]
  Library,
  #[serde(untagged)]
  Custom(String),
}

impl TargetEnv {
  pub fn is_browser(&self) -> bool {
    matches!(self, TargetEnv::Browser)
  }

  pub fn is_node(&self) -> bool {
    matches!(self, TargetEnv::Node)
  }

  pub fn is_library(&self) -> bool {
    matches!(self, TargetEnv::Library)
  }
}

impl ToString for TargetEnv {
  fn to_string(&self) -> String {
    match self {
      TargetEnv::Browser => "browser".to_string(),
      TargetEnv::Node => "node".to_string(),
      TargetEnv::Library => "library".to_string(),
      TargetEnv::Custom(s) => s.clone(),
    }
  }
}

#[derive(Debug, Copy, Clone, Serialize, Deserialize, Eq, PartialEq, Hash, Default)]
pub enum ModuleFormat {
  #[serde(rename = "esm")]
  #[default]
  EsModule,
  #[serde(rename = "cjs")]
  CommonJs,
  #[serde(rename = "iife")]
  IIFE,
  #[serde(rename = "umd")]
  UMD,
  #[serde(rename = "system")]
  System,
  #[serde(rename = "amd")]
  AMD,
}

#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq, Hash)]
#[serde(untagged)]
pub enum ModuleFormatConfig {
  Single(ModuleFormat),
  Multiple(Vec<ModuleFormat>),
}

impl Default for ModuleFormatConfig {
  fn default() -> Self {
    Self::Single(ModuleFormat::default())
  }
}

impl ModuleFormatConfig {
  pub fn as_single(&self) -> ModuleFormat {
    match self {
      ModuleFormatConfig::Single(module_format) => *module_format,
      ModuleFormatConfig::Multiple(_) => {
        unreachable!("Multiple output.format is only allowed when output.target_env is library")
      }
    }
  }

  pub fn contains_esm(&self) -> bool {
    match self {
      ModuleFormatConfig::Single(module_format) => *module_format == ModuleFormat::EsModule,
      ModuleFormatConfig::Multiple(module_formats) => {
        module_formats.contains(&ModuleFormat::EsModule)
      }
    }
  }

  pub fn contains_cjs(&self) -> bool {
    match self {
      ModuleFormatConfig::Single(module_format) => *module_format == ModuleFormat::CommonJs,
      ModuleFormatConfig::Multiple(module_formats) => {
        module_formats.contains(&ModuleFormat::CommonJs)
      }
    }
  }
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy, Default, PartialEq, Eq)]
pub enum LibraryBundleType {
  #[serde(rename = "single-bundle")]
  #[default]
  SingleBundle,
  /// TODO set default to MultipleBundle when multiple bundle is fully supported
  #[serde(rename = "multiple-bundle")]
  MultipleBundle,
  #[serde(rename = "bundle-less")]
  BundleLess,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase", default)]
pub struct OutputConfig {
  pub path: String,
  pub public_path: String,
  pub entry_filename: String,
  pub filename: String,
  pub assets_filename: String,
  pub target_env: TargetEnv,
  pub format: ModuleFormatConfig,
  pub show_file_size: bool,
  pub library_bundle_type: LibraryBundleType,
  pub ascii_only: bool,
  /// external globals name, for example, if you set `external_globals: {"react": "React"}`,
  /// if you use `import * as React from 'react'`, you can access `React` from `window.React`
  /// NOTE: only works when `target_env` is `browser`, or `library` with format `iife` or `umd`
  pub external_globals: HashMap<String, String>,
}

impl Default for OutputConfig {
  fn default() -> Self {
    Self {
      entry_filename: "[entryName].[ext]".to_string(),
      // [resourceName].[contentHash].[ext]
      filename: "[resourceName].[ext]".to_string(),
      // [resourceName].[contentHash].[ext]
      assets_filename: "[resourceName].[ext]".to_string(),
      public_path: "/".to_string(),
      path: "dist".to_string(),
      target_env: TargetEnv::default(),
      format: ModuleFormatConfig::default(),
      show_file_size: true,
      library_bundle_type: Default::default(),
      ascii_only: false,
      external_globals: HashMap::default(),
    }
  }
}