hni 0.0.1-alpha-2

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

use crate::core::types::PackageManager;

use super::flags::{npm_run_args, prepend};

pub fn version_command_for_pm(pm: PackageManager) -> (String, Vec<String>) {
    (pm.bin().to_string(), vec!["--version".to_string()])
}

pub(super) fn install_command(pm: PackageManager, args: Vec<String>) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), prepend("i", args)),
        PackageManager::Yarn | PackageManager::YarnBerry => {
            ("yarn".to_string(), prepend("install", args))
        }
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("i", args)),
        PackageManager::Bun => ("bun".to_string(), prepend("install", args)),
        PackageManager::Deno => ("deno".to_string(), prepend("install", args)),
    }
}

pub(super) fn add_command(pm: PackageManager, args: Vec<String>) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), prepend("i", args)),
        PackageManager::Yarn | PackageManager::YarnBerry => {
            ("yarn".to_string(), prepend("add", args))
        }
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("add", args)),
        PackageManager::Bun => ("bun".to_string(), prepend("add", args)),
        PackageManager::Deno => ("deno".to_string(), prepend("add", args)),
    }
}

pub(super) fn run_command(pm: PackageManager, args: Vec<String>) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), npm_run_args(args)),
        PackageManager::Yarn | PackageManager::YarnBerry => {
            ("yarn".to_string(), prepend("run", args))
        }
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("run", args)),
        PackageManager::Bun => ("bun".to_string(), prepend("run", args)),
        PackageManager::Deno => ("deno".to_string(), prepend("task", args)),
    }
}

pub(super) fn execute_command(pm: PackageManager, args: Vec<String>) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm | PackageManager::Yarn => ("npx".to_string(), args),
        PackageManager::YarnBerry => ("yarn".to_string(), prepend("dlx", args)),
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("dlx", args)),
        PackageManager::Bun => ("bun".to_string(), prepend("x", args)),
        PackageManager::Deno => {
            if let Some((first, rest)) = args.split_first() {
                let mut deno_args = vec!["run".to_string(), format!("npm:{first}")];
                deno_args.extend(rest.iter().cloned());
                ("deno".to_string(), deno_args)
            } else {
                ("deno".to_string(), vec!["run".to_string()])
            }
        }
    }
}

pub(super) fn upgrade_command(pm: PackageManager, args: Vec<String>) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), prepend("update", args)),
        PackageManager::Yarn => ("yarn".to_string(), prepend("upgrade", args)),
        PackageManager::YarnBerry => ("yarn".to_string(), prepend("up", args)),
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("update", args)),
        PackageManager::Bun => ("bun".to_string(), prepend("update", args)),
        PackageManager::Deno => (
            "deno".to_string(),
            prepend("outdated", prepend("--update", args)),
        ),
    }
}

pub(super) fn uninstall_command(pm: PackageManager, args: Vec<String>) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), prepend("uninstall", args)),
        PackageManager::Yarn | PackageManager::YarnBerry => {
            ("yarn".to_string(), prepend("remove", args))
        }
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("remove", args)),
        PackageManager::Bun => ("bun".to_string(), prepend("remove", args)),
        PackageManager::Deno => ("deno".to_string(), prepend("remove", args)),
    }
}

pub(super) fn frozen_command(pm: PackageManager) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), vec!["ci".to_string()]),
        PackageManager::Yarn => (
            "yarn".to_string(),
            vec!["install".to_string(), "--frozen-lockfile".to_string()],
        ),
        PackageManager::YarnBerry => (
            "yarn".to_string(),
            vec!["install".to_string(), "--immutable".to_string()],
        ),
        PackageManager::Pnpm => (
            "pnpm".to_string(),
            vec!["i".to_string(), "--frozen-lockfile".to_string()],
        ),
        PackageManager::Bun => (
            "bun".to_string(),
            vec!["install".to_string(), "--frozen-lockfile".to_string()],
        ),
        PackageManager::Deno => (
            "deno".to_string(),
            vec!["install".to_string(), "--frozen".to_string()],
        ),
    }
}

pub(super) fn global_install_command(
    pm: PackageManager,
    args: Vec<String>,
) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), prepend("i", prepend("-g", args))),
        PackageManager::Yarn | PackageManager::YarnBerry => yarn_global_command("add", args),
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("add", prepend("-g", args))),
        PackageManager::Bun => ("bun".to_string(), prepend("add", prepend("-g", args))),
        PackageManager::Deno => ("deno".to_string(), prepend("install", prepend("-g", args))),
    }
}

pub(super) fn global_uninstall_command(
    pm: PackageManager,
    args: Vec<String>,
) -> (String, Vec<String>) {
    match pm {
        PackageManager::Npm => ("npm".to_string(), prepend("uninstall", prepend("-g", args))),
        PackageManager::Yarn | PackageManager::YarnBerry => yarn_global_command("remove", args),
        PackageManager::Pnpm => ("pnpm".to_string(), prepend("remove", prepend("-g", args))),
        PackageManager::Bun => ("bun".to_string(), prepend("remove", prepend("-g", args))),
        PackageManager::Deno => (
            "deno".to_string(),
            prepend("uninstall", prepend("-g", args)),
        ),
    }
}

fn yarn_global_command(action: &str, args: Vec<String>) -> (String, Vec<String>) {
    let mut out = vec!["global".to_string(), action.to_string()];
    out.extend(args);
    ("yarn".to_string(), out)
}