nodejs-resolver 0.1.1

nodejs resolve
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

use super::Plugin;
use crate::{description::DescriptionData, log::color, log::depth, Context, Info, Resolver, State};

pub struct MainFieldPlugin<'a> {
    pkg_info: &'a DescriptionData,
}

impl<'a> MainFieldPlugin<'a> {
    pub fn new(pkg_info: &'a DescriptionData) -> Self {
        Self { pkg_info }
    }
}

impl<'a> Plugin for MainFieldPlugin<'a> {
    fn apply(&self, resolver: &Resolver, info: Info, context: &mut Context) -> State {
        let resolved = info.to_resolved_path();
        if !self.pkg_info.dir().as_ref().eq(&*resolved) {
            return State::Resolving(info);
        }
        let main_field_info = info.clone().with_path(resolved).with_target(".");

        for user_main_field in &resolver.options.main_fields {
            if let Some(main_field) = self
                .pkg_info
                .data()
                .raw()
                .get(user_main_field)
                .and_then(|value| value.as_str())
            {
                if main_field == "." || main_field == "./" {
                    // if it pointed to itself.
                    break;
                }
                tracing::debug!(
                    "MainField in '{}' works, using {} field({})",
                    color::blue(&format!("{:?}/package.json", self.pkg_info.dir().as_ref())),
                    color::blue(user_main_field),
                    depth(&context.depth)
                );

                let main_field_info = if main_field.starts_with("./") {
                    main_field_info.clone().with_target(main_field)
                } else {
                    main_field_info
                        .clone()
                        .with_target(&format!("./{main_field}"))
                };

                let fully_specified = context.fully_specified.get();
                if fully_specified {
                    context.fully_specified.set(false);
                }
                let state = resolver._resolve(main_field_info, context);
                if fully_specified {
                    context.fully_specified.set(true);
                }
                if state.is_finished() {
                    return state;
                }
                tracing::debug!("Leaving MainField({})", depth(&context.depth));
            }
        }
        State::Resolving(info)
    }
}