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

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

use crate::Cache;

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum AliasMap {
    Target(String),
    Ignored,
}

#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub enum EnforceExtension {
    Enabled,
    Disabled,
    Auto,
}

pub type Alias = Vec<(String, Vec<AliasMap>)>;

#[derive(Debug, Clone)]
pub struct Options {
    /// Tried detect file with this extension.
    /// Default is `[".js", ".json", ".node"]`
    pub extensions: Vec<String>,
    /// Enforce that a extension from extensions must be used.
    /// Default is `Auto`.
    pub enforce_extension: EnforceExtension,
    /// Maps key to value.
    /// Default is `vec![]`.
    /// The reason for using `Vec` instead `HashMap` to keep the order.
    pub alias: Alias,
    /// Prefer to resolve request as relative request and
    /// fallback to resolving as modules.
    /// Default is `false`
    pub prefer_relative: bool,
    /// Use of cache defined external, it designed to shared the info of `description_file`
    /// in different resolver.
    ///
    /// - If `external_cache` is `None`, use default cache in resolver.
    /// - If `external_cache.is_some()` is true, use this cache.
    ///
    /// Default is `None`.
    pub external_cache: Option<Arc<Cache>>,
    /// Whether to resolve the real path when the result
    /// is a symlink.
    /// Default is `true`.
    pub symlinks: bool,
    /// A JSON file to describing this lib information.
    /// Default is `"package.json"`.
    pub description_file: String,
    /// Resolve to a context instead of a file.
    /// Default is `false`
    pub resolve_to_context: bool,
    /// Main file in this directory.
    /// Default is `["index"]`.
    pub main_files: Vec<String>,
    /// Main fields in Description.
    /// Default is `["main"]`.
    pub main_fields: Vec<String>,
    /// Whether read and parse `"browser"` filed
    /// in package.json.
    /// Default is `false`
    pub browser_field: bool,
    /// Condition names for exports filed. Note that its type is a `HashSet`,
    /// because the priority is related to the order in which the export field
    /// fields are written.
    /// Default is `[]`.
    pub condition_names: HashSet<String>,
    /// When this filed exists, it tries to read `baseURL`
    /// and `paths` in the corresponding tsconfig,
    /// and processes the mappings.
    /// Default is `None`.
    pub tsconfig: Option<PathBuf>,
    /// A list of directories to resolve modules from, can be absolute path or folder name.
    /// Default is `["node_modules"]`
    pub modules: Vec<String>,
    /// Same as `alias`, but only used if default resolving fails.
    /// Default is `[]`.
    pub fallback: Alias,
    /// Request passed to resolve is already fully specified and
    /// extensions or main files are not resolved for it.
    /// Default is `false`.
    pub fully_specified: bool,
    /// A list of exports fields in descriptions files
    /// Default is `[["exports"]]`.
    pub exports_field: Vec<Vec<String>>,
    /// A vector which maps extension to extension aliases.
    /// Default is `[]`.
    pub extension_alias: Vec<(String, Vec<String>)>,
}

impl Default for Options {
    fn default() -> Self {
        let extensions = vec![
            String::from(".js"),
            String::from(".json"),
            String::from(".node"),
        ];
        let main_files = vec![String::from("index")];
        let main_fields = vec![String::from("main")];
        let description_file = String::from("package.json");
        let alias = vec![];
        let symlinks = true;
        let browser_field = false;
        let condition_names = HashSet::default();
        let prefer_relative = false;
        let enforce_extension = EnforceExtension::Auto;
        let tsconfig = None;
        let external_cache = None;
        let resolve_to_context = false;
        let modules = vec![String::from("node_modules")];
        let fallback = vec![];
        let fully_specified = false;
        let exports_field = vec![vec![String::from("exports")]];
        let extension_alias = vec![];
        Self {
            fallback,
            modules,
            extensions,
            enforce_extension,
            alias,
            prefer_relative,
            external_cache,
            symlinks,
            description_file,
            resolve_to_context,
            main_files,
            main_fields,
            browser_field,
            condition_names,
            tsconfig,
            fully_specified,
            exports_field,
            extension_alias,
        }
    }
}