cnp 1.0.1

A utility tool written in Rust to check unused node packages.
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

use crate::config::{EXTENSIONS, IGNORE_FOLDERS};
use glob::glob;
use indicatif::ProgressBar;
use regex::Regex;
use std::collections::HashSet;
use std::ffi::OsStr;
use std::fs;
use std::path::Path;

// Helper function to normalize paths for macOS
fn normalize_path(path: &Path) -> String {
    let path_str = fs::canonicalize(path)
        .map(|p| p.display().to_string())
        .unwrap_or_else(|_| path.display().to_string());
    // On macOS, strip /private prefix if present
    if cfg!(target_os = "macos") && path_str.starts_with("/private") {
        path_str.replacen("/private", "", 1)
    } else {
        path_str
    }
}

pub fn scan_files(
    dependencies: &HashSet<String>,
    pb: &ProgressBar,
) -> (HashSet<String>, Vec<String>, Vec<String>) {
    let patterns: Vec<String> = EXTENSIONS
        .iter()
        .map(|ext| format!("**/*.{}", ext))
        .collect();
    let mut used_packages = HashSet::new();
    let mut ignored_files = Vec::new();
    let mut explored_files = Vec::new();
    let mut seen_paths = HashSet::new();

    for pattern in patterns {
        for entry in glob(&pattern).expect("Failed to read glob pattern") {
            pb.inc(1);
            match entry {
                Ok(path) if !path.is_dir() && !path.is_symlink() => {
                    let abs_path = normalize_path(&path);
                    if seen_paths.contains(&abs_path) {
                        continue;
                    }
                    seen_paths.insert(abs_path.clone());
                    if should_ignore(&path) {
                        ignored_files.push(abs_path);
                        continue;
                    }
                    if let Ok(content) = fs::read_to_string(&path) {
                        used_packages.extend(find_dependencies_in_content(&content, dependencies));
                    }
                    explored_files.push(abs_path);
                }
                Ok(path) => {
                    let abs_path = normalize_path(&path);
                    if should_ignore(&path) && !seen_paths.contains(&abs_path) {
                        ignored_files.push(abs_path.clone());
                        seen_paths.insert(abs_path);
                    }
                }
                Err(_) => {}
            }
        }
    }

    (used_packages, explored_files, ignored_files)
}

fn find_dependencies_in_content(content: &str, dependencies: &HashSet<String>) -> HashSet<String> {
    let mut found = HashSet::new();
    for dep in dependencies {
        let dep_pattern = if dep.starts_with('@') {
            let parts: Vec<&str> = dep.split('/').collect();
            if parts.len() > 1 {
                format!("{}/{}", parts[0], parts[1])
            } else {
                dep.clone()
            }
        } else {
            dep.clone()
        };

        let import_from_regex = Regex::new(&format!(
            r#"import\s+.*?\s+from\s+['"]({}(/[^'"]*)?)['"]"#,
            regex::escape(&dep_pattern)
        ))
        .unwrap();
        let require_regex = Regex::new(&format!(
            r#"require\s*\(\s*['"]({}(/[^'"]*)?)['"]\s*\)"#,
            regex::escape(&dep_pattern)
        ))
        .unwrap();
        let import_simple_regex = Regex::new(&format!(
            r#"import\s+['"]({}(/[^'"]*)?)['"]\s*;"#,
            regex::escape(&dep_pattern)
        ))
        .unwrap();

        if import_from_regex.is_match(content)
            || require_regex.is_match(content)
            || import_simple_regex.is_match(content)
        {
            found.insert(dep.clone());
        }
    }
    found
}

fn should_ignore(path: &Path) -> bool {
    path.components().any(|component| {
        IGNORE_FOLDERS
            .iter()
            .any(|folder| component.as_os_str() == OsStr::new(folder))
    })
}