oxc_resolver 11.19.1

ESM / CJS module resolution
Documentation 
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

//! <https://github.com/webpack/enhanced-resolve/blob/main/test/roots.test.js>

use std::path::PathBuf;

use crate::{AliasValue, ResolveError, ResolveOptions, Resolver};

fn dirname() -> PathBuf {
    super::fixture_root().join("enhanced-resolve").join("test")
}

#[test]
fn roots() {
    let f = super::fixture();

    let resolver = Resolver::new(ResolveOptions {
        extensions: vec![".js".into()],
        alias: vec![("foo".into(), vec![AliasValue::from("/fixtures")])],
        roots: vec![dirname(), f.clone()],
        ..ResolveOptions::default()
    });

    #[rustfmt::skip]
    let pass = [
        ("should respect roots option", "/fixtures/b.js", f.join("b.js")),
        ("should try another root option, if it exists", "/b.js", f.join("b.js")),
        ("should respect extension", "/fixtures/b", f.join("b.js")),
        ("should resolve in directory", "/fixtures/extensions/dir", f.join("extensions/dir/index.js")),
        ("should respect aliases", "foo/b", f.join("b.js")),
    ];

    for (comment, request, expected) in pass {
        let resolved_path = resolver.resolve(&f, request).map(|r| r.full_path());
        assert_eq!(resolved_path, Ok(expected), "{comment} {request}");
    }

    #[rustfmt::skip]
    let fail = [
        ("should not work with relative path", "fixtures/b.js", ResolveError::NotFound("fixtures/b.js".into()))
    ];

    for (comment, request, expected) in fail {
        let resolution = resolver.resolve(&f, request);
        assert_eq!(resolution, Err(expected), "{comment} {request}");
    }
}

#[test]
fn resolve_to_context() {
    let f = super::fixture();
    let resolver = Resolver::new(ResolveOptions {
        roots: vec![dirname(), f.clone()],
        resolve_to_context: true,
        ..ResolveOptions::default()
    });
    let resolved_path = resolver.resolve(&f, "/fixtures/lib").map(|r| r.full_path());
    let expected = f.join("lib");
    assert_eq!(resolved_path, Ok(expected));
}

#[test]
fn prefer_absolute() {
    let f = super::fixture();
    let resolver = Resolver::new(ResolveOptions {
        extensions: vec![".js".into()],
        alias: vec![("foo".into(), vec![AliasValue::from("/fixtures")])],
        roots: vec![dirname(), f.clone()],
        prefer_absolute: true,
        ..ResolveOptions::default()
    });

    #[rustfmt::skip]
    let pass = [
        ("should resolve an absolute path (prefer absolute)", f.join("b.js").to_string_lossy().to_string(), f.join("b.js")),
    ];

    for (comment, request, expected) in pass {
        let resolved_path = resolver.resolve(&f, &request).map(|r| r.full_path());
        assert_eq!(resolved_path, Ok(expected), "{comment} {request}");
    }
}

#[test]
fn roots_fall_through() {
    let f = super::fixture();
    let absolute_path = f.join("roots-fall-through/index.js");
    let specifier = absolute_path.to_string_lossy();
    let resolution = Resolver::new(ResolveOptions::default().with_root(&f)).resolve(&f, &specifier);
    assert_eq!(
        resolution.map(super::super::resolution::Resolution::into_path_buf),
        Ok(absolute_path)
    );
}

#[test]
fn should_resolve_slash() {
    let f = super::fixture();
    let dir_with_index = super::fixture_root().join("./misc/dir-with-index");

    #[rustfmt::skip]
    let pass = [
        ("should resolve if importer is root", vec![dir_with_index.clone()], &dir_with_index, dir_with_index.join("index.js")),
    ];

    for (comment, roots, directory, expected) in pass {
        let resolver =
            Resolver::new(ResolveOptions { roots: roots.clone(), ..ResolveOptions::default() });
        let resolved_path = resolver.resolve(directory, "/").map(|r| r.full_path());
        assert_eq!(resolved_path, Ok(expected), "{comment} {roots:?}");
    }

    #[rustfmt::skip]
    let fail = [
        ("should not resolve if not found", vec![f.clone()], &f),
        ("should not resolve if importer is not root", vec![dir_with_index], &f)
    ];

    for (comment, roots, directory) in fail {
        let resolver =
            Resolver::new(ResolveOptions { roots: roots.clone(), ..ResolveOptions::default() });
        let resolution = resolver.resolve(directory, "/");
        assert_eq!(resolution, Err(ResolveError::NotFound("/".into())), "{comment} {roots:?}");
    }
}