oj_css 0.2.22

CSS pipeline: Lightning CSS transforms, CSS Modules scoping
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

//! Path and url helpers shared by the resolvers.

use std::path::{Component, Path, PathBuf};

/// `p` with `.ext` appended (not replacing an existing extension).
pub(crate) fn with_ext(p: &Path, ext: &str) -> PathBuf {
    let mut s = p.as_os_str().to_owned();
    s.push(".");
    s.push(ext);
    PathBuf::from(s)
}

/// `url` without its `?query` / `#hash`.
pub(crate) fn strip_query(url: &str) -> &str {
    split_query(url).0
}

/// `url` split into its path and its `?query` / `#hash` suffix.
pub(crate) fn split_query(url: &str) -> (&str, &str) {
    url.split_at(url.find(['?', '#']).unwrap_or(url.len()))
}

/// Lexical normalization: `.` dropped, `..` pops. No filesystem access.
pub(crate) fn normalize(p: &Path) -> PathBuf {
    let mut out = PathBuf::new();
    for c in p.components() {
        match c {
            Component::ParentDir => {
                out.pop();
            }
            Component::CurDir => {}
            other => out.push(other),
        }
    }
    out
}

/// `target` relative to `from_dir`, `/`-separated, `./`-led unless it starts
/// with `..`.
pub(crate) fn relative_path(from_dir: &Path, target: &Path) -> String {
    let segments = |p: &Path| -> Vec<String> {
        normalize(p)
            .components()
            .filter_map(|c| match c {
                Component::Normal(s) => Some(s.to_string_lossy().into_owned()),
                _ => None,
            })
            .collect()
    };
    let from = segments(from_dir);
    let to = segments(target);
    let common = from.iter().zip(&to).take_while(|(a, b)| a == b).count();
    let mut parts = vec![".."; from.len() - common];
    parts.extend(to[common..].iter().map(String::as_str));
    let joined = parts.join("/");
    if joined.starts_with("..") {
        joined
    } else {
        format!("./{joined}")
    }
}

/// The relative path `rel` joined onto the relative path `base` (a
/// `relative_path` result), in the same `./` / `../` form.
pub(crate) fn join_relative(base: &str, rel: &str) -> String {
    let mut segments: Vec<&str> = base
        .split('/')
        .filter(|s| !s.is_empty() && *s != ".")
        .collect();
    for part in rel.split('/') {
        match part {
            "" | "." => {}
            ".." if segments.last().is_some_and(|s| *s != "..") => {
                segments.pop();
            }
            other => segments.push(other),
        }
    }
    let joined = segments.join("/");
    if joined.starts_with("..") {
        joined
    } else {
        format!("./{joined}")
    }
}

/// `rel` joined onto the url directory `base_dir`, resolving `.` and `..`.
pub(crate) fn posix_join(base_dir: &str, rel: &str) -> String {
    let mut segments: Vec<&str> = base_dir.split('/').filter(|s| !s.is_empty()).collect();
    for part in rel.split('/') {
        match part {
            "" | "." => {}
            ".." => {
                segments.pop();
            }
            other => segments.push(other),
        }
    }
    format!("/{}", segments.join("/"))
}

/// Every `node_modules` directory from `dir` up to the filesystem root,
/// nearest first.
pub fn node_modules_load_paths(dir: &Path) -> Vec<PathBuf> {
    dir.ancestors()
        .filter(|d| d.file_name().is_none_or(|n| n != "node_modules"))
        .map(|d| d.join("node_modules"))
        .filter(|nm| nm.is_dir())
        .collect()
}

/// `dir/package.json`, parsed.
pub(crate) fn read_package_json(dir: &Path) -> Option<serde_json::Value> {
    let text = std::fs::read_to_string(dir.join("package.json")).ok()?;
    serde_json::from_str(&text).ok()
}

/// A url that points off the local filesystem: `data:`, `//host`, `scheme://`.
pub(crate) fn is_external(spec: &str) -> bool {
    spec.starts_with("data:") || spec.starts_with("//") || spec.contains("://")
}