nci 0.2.1

Use the right package manager
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

use std::{process, vec};

use console::style;
use inquire::{Select, Text};
use nci::{fetch::fetch_npm_packages, parse::parse_ni, runner::run_cli, utils::exclude};
use tokio::runtime::Runtime;

fn main() {
    run_cli(
        |agent, mut args, ctx| {
            let is_interactive = args.get(0) == Some(&"-i".to_string());

            if is_interactive {
                let fetch_pattern = match args.get(1) {
                    Some(pattern) => pattern.clone(),
                    None => match Text::new("search for package").prompt() {
                        Ok(pattern) => pattern,
                        Err(_) => process::exit(1),
                    },
                };

                // fetch npm packages
                let packages = Runtime::new()
                    .unwrap()
                    .block_on(fetch_npm_packages(&fetch_pattern));
                let packages = match packages {
                    Ok(packages) => {
                        if packages.len() == 0 {
                            println!("No results found");
                            process::exit(1);
                        } else {
                            packages
                        }
                    }
                    Err(_) => {
                        eprintln!("Failed to fetch packages");
                        process::exit(1);
                    }
                };

                // select package
                let dependency = Select::new("choose a package to install", {
                    packages.iter().map(|pkg| pkg.value.name.clone()).collect()
                })
                .prompt();
                let dependency = match dependency {
                    Ok(dependency) => dependency,
                    Err(_) => process::exit(1),
                };

                args = exclude(
                    &args,
                    &["-d".to_string(), "-p".to_string(), "-i".to_string()],
                );

                // yarn and bun do not support the installation of peers programmatically
                let can_install_peers = ["npm", "pnpm"].contains(&agent.as_str());

                // select install mode
                let mode = Select::new(&format!("install {} as", style(&dependency).yellow()), {
                    if can_install_peers {
                        vec!["-prod", "-dev", "--save-peer"]
                    } else {
                        vec!["-prod", "-dev"]
                    }
                })
                .prompt();
                let mode = match mode {
                    Ok(mode) => mode,
                    Err(_) => process::exit(1),
                };

                args.extend(vec![dependency.to_string(), mode.to_string()]);
            }

            parse_ni(agent, args, ctx)
        },
        None,
    );
}