hni 0.0.3

ni-compatible package manager command router with node shim
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

mod bin_resolver;
mod eligibility;
mod env;
mod exec;
mod plan;
mod shim_parser;

use std::path::Path;

use anyhow::Result;

use crate::core::{
    resolve::{LocalBinProjectState, ProjectState, ResolveContext},
    types::{NativeDenoTaskExecution, PackageManager, ResolvedExecution},
};

use plan::{NativeDecision, NativePlan};

pub(crate) fn looks_like_env_assignment(token: &str) -> bool {
    token.contains('=') && !token.starts_with('-')
}

pub(crate) fn is_node_program(program: &str) -> bool {
    Path::new(program)
        .file_name()
        .and_then(|value| value.to_str())
        .is_some_and(|value| {
            value.eq_ignore_ascii_case("node") || value.eq_ignore_ascii_case("node.exe")
        })
}

pub enum NativeAttempt {
    Eligible(Box<ResolvedExecution>),
    Ineligible(String),
}

pub(crate) fn attempt_nr_from_state(
    pm: Option<PackageManager>,
    args: &[String],
    ctx: &ResolveContext,
    state: &ProjectState,
    has_if_present: bool,
) -> Result<NativeAttempt> {
    let decision = crate::core::profile::measure("native.plan_nr", || {
        eligibility::plan_nr_from_state(pm, args, ctx, state, has_if_present)
    })?;
    crate::core::profile::measure("native.materialize", || into_attempt(decision, ctx.cwd()))
}

pub(crate) fn attempt_nlx_from_local_bin_state(
    pm: Option<PackageManager>,
    args: &[String],
    ctx: &ResolveContext,
    state: &LocalBinProjectState,
) -> Result<NativeAttempt> {
    let decision = crate::core::profile::measure("native.plan_nlx", || {
        eligibility::plan_nlx_from_local_bin_state(pm, args, state)
    })?;
    crate::core::profile::measure("native.materialize", || into_attempt(decision, ctx.cwd()))
}

pub fn run_script(
    exec: &crate::core::types::NativeScriptExecution,
    invocation_cwd: &Path,
) -> Result<std::process::ExitCode> {
    exec::run_script(exec, invocation_cwd)
}

pub fn run_deno_task(
    exec: &NativeDenoTaskExecution,
    invocation_cwd: &Path,
) -> Result<std::process::ExitCode> {
    exec::run_deno_task(exec, invocation_cwd)
}

pub fn run_local_bin(
    exec: &crate::core::types::NativeLocalBinExecution,
    cwd: &Path,
) -> Result<std::process::ExitCode> {
    exec::run_local_bin(exec, cwd)
}

pub fn format_debug(exec: &ResolvedExecution) -> String {
    exec::format_debug(exec)
}

fn into_attempt(decision: NativeDecision, cwd: &Path) -> Result<NativeAttempt> {
    Ok(match decision {
        NativeDecision::Eligible(plan) => NativeAttempt::Eligible(Box::new(match plan {
            NativePlan::Script(exec) => {
                ResolvedExecution::native_script(exec.script_name.clone(), cwd.to_path_buf(), exec)
            }
            NativePlan::DenoTask(exec) => {
                ResolvedExecution::native_deno_task(exec.selection.clone(), cwd.to_path_buf(), exec)
            }
            NativePlan::LocalBin(exec) => {
                ResolvedExecution::native_local_bin(exec.bin_name.clone(), cwd.to_path_buf(), exec)
            }
        })),
        NativeDecision::Ineligible(reason) => NativeAttempt::Ineligible(reason.to_string()),
    })
}