atmos/os_lib/css/

values.rs

// 分割: css.rs より機械的に移動（2026-07-16 リファクタ フェーズ3）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

/// Replace all `var(--name)` and `var(--name, fallback)` occurrences in a value string.
/// カスタムプロパティが別のカスタムプロパティを参照する間接参照
/// （例: `--a: var(--b); --b: red;` のとき `var(--a)` は `red` に解決される）に対応するため、
/// 1パスの置換結果にまだ `var(` が残っていれば再帰的に解決する。循環参照時に無限再帰へ
/// 陥らないよう、最大再帰深度（8）を設けて打ち切る。
pub fn resolve_css_var(value: &str, vars: &BTreeMap<String, String>) -> String {
    resolve_css_var_depth(value, vars, 0)
}

pub(crate) fn resolve_css_var_depth(value: &str, vars: &BTreeMap<String, String>, depth: u32) -> String {
    if depth >= 8 {
        return String::from(value);
    }
    let mut result = String::new();
    let mut rest = value;
    while let Some(start) = rest.find("var(") {
        result.push_str(rest.get(..start).unwrap_or(""));
        let after = rest.get(start + 4..).unwrap_or("");
        // find matching closing paren
        let mut depth_paren = 1usize;
        let mut end = 0;
        for (i, c) in after.char_indices() {
            match c {
                '(' => depth_paren += 1,
                ')' => {
                    depth_paren -= 1;
                    if depth_paren == 0 {
                        end = i;
                        break;
                    }
                }
                _ => {}
            }
        }
        let inner = after.get(..end).unwrap_or("");
        // split on first comma for fallback
        let (var_name, fallback) = if let Some(comma_pos) = inner.find(',') {
            (
                inner.get(..comma_pos).unwrap_or("").trim(),
                Some(inner.get(comma_pos + 1..).unwrap_or("").trim()),
            )
        } else {
            (inner.trim(), None)
        };
        let resolved = vars
            .get(var_name)
            .cloned()
            .or_else(|| fallback.map(|s| s.to_string()))
            .unwrap_or_default();
        // 参照先の値自体が別の var(...) を含む場合（間接参照）は再帰的に解決する。
        let resolved = if resolved.contains("var(") {
            resolve_css_var_depth(&resolved, vars, depth + 1)
        } else {
            resolved
        };
        result.push_str(&resolved);
        rest = after.get(end + 1..).unwrap_or("");
    }
    result.push_str(rest);
    result
}

/// `env(safe-area-inset-*)`等（CSS Environment Variables）を解決する。
/// この処理系にはノッチ/デバイスセーフエリアという概念自体が存在しない
/// （実機はRaspberry Pi 3B、ヘッドレスQEMU）ため、`var()`のような真の
/// 環境変数テーブルは持たず、既知の`safe-area-inset-*`/
/// `viewport-segment-*`系は常に`"0px"`、フォールバック指定があればそちらを
/// 優先する「正直な既定値ゼロ」として解決する（丸ごと未対応だった。
/// 2026-07-18 発見・実装）。
pub fn resolve_css_env(value: &str) -> String {
    let mut result = String::new();
    let mut rest = value;
    while let Some(start) = rest.find("env(") {
        result.push_str(rest.get(..start).unwrap_or(""));
        let after = rest.get(start + 4..).unwrap_or("");
        let mut depth_paren = 1usize;
        let mut end = 0;
        for (i, c) in after.char_indices() {
            match c {
                '(' => depth_paren += 1,
                ')' => {
                    depth_paren -= 1;
                    if depth_paren == 0 {
                        end = i;
                        break;
                    }
                }
                _ => {}
            }
        }
        let inner = after.get(..end).unwrap_or("");
        let (_env_name, fallback) = if let Some(comma_pos) = inner.find(',') {
            (
                inner.get(..comma_pos).unwrap_or("").trim(),
                Some(inner.get(comma_pos + 1..).unwrap_or("").trim()),
            )
        } else {
            (inner.trim(), None)
        };
        let resolved = fallback.unwrap_or("0px").to_string();
        let resolved = if resolved.contains("env(") {
            resolve_css_env(&resolved)
        } else {
            resolved
        };
        result.push_str(&resolved);
        rest = after.get(end + 1..).unwrap_or("");
    }
    result.push_str(rest);
    result
}

/// `calc()`内の単一トークン（`10px`/`50%`/`2rem`/裸の数値等）をpxへ変換する。
fn parse_calc_unit(s: &str, containing_width: i32) -> Option<f32> {
    let s = s.trim();
    if s.is_empty() {
        return None;
    }
    if let Some(n) = s.strip_suffix("px") {
        return n.trim().parse::<f32>().ok();
    }
    // `vh`/`vw`/`vmin`/`vmax`/絶対長さ単位（丸ごと未対応だった。以前は
    // `px`/`rem`/`em`/`%`の4種のみで、`calc(50vw + 10px)`のようなビュー
    // ポート単位を含む式が丸ごと評価失敗（`None`）していた。
    // `eval_length_token`（`min()`/`max()`/`clamp()`用の同種パーサ。
    // 2026-07-17に同じ単位対応を追加済み）と揃える。`vmin`は`in`判定より
    // 前に置く（末尾2文字が`"in"`と一致するため順序を誤ると誤吸収される）。
    // 2026-07-17 発見・実装）。
    if let Some(n) = s.strip_suffix("vh") {
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * h as f32);
    }
    if let Some(n) = s.strip_suffix("vw") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w as f32);
    }
    if let Some(n) = s.strip_suffix("vmin") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.min(h) as f32);
    }
    if let Some(n) = s.strip_suffix("vmax") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.max(h) as f32);
    }
    if let Some(n) = s.strip_suffix("rem") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = s.strip_suffix("em") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = s.strip_suffix('%') {
        return n
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| v / 100.0 * containing_width as f32);
    }
    if let Some(n) = s.strip_suffix("in") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0);
    }
    if let Some(n) = s.strip_suffix("cm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 2.54);
    }
    if let Some(n) = s.strip_suffix("mm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 25.4);
    }
    if let Some(n) = s.strip_suffix("pt") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 72.0);
    }
    if let Some(n) = s.strip_suffix("pc") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = s.strip_suffix('q') {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 101.6);
    }
    s.parse::<f32>().ok()
}

/// バイト位置`*pos`以降の空白をスキップする。
fn calc_skip_ws(bytes: &[u8], pos: &mut usize) {
    while *pos < bytes.len() && bytes[*pos] == b' ' {
        *pos += 1;
    }
}

/// `factor := '(' expr ')' | <数値+単位トークン>`。
/// 丸括弧が来れば対応する閉じ括弧まで走査し`parse_calc_expr`へ再帰する
/// （`calc((100% - 20px) / 2)`のようなネストに対応するため）。
fn parse_calc_factor(s: &str, pos: &mut usize, containing_width: i32) -> Option<f32> {
    let bytes = s.as_bytes();
    calc_skip_ws(bytes, pos);
    if bytes.get(*pos) == Some(&b'(') {
        *pos += 1;
        let start = *pos;
        let mut depth = 1i32;
        while *pos < bytes.len() && depth > 0 {
            match bytes[*pos] {
                b'(' => depth += 1,
                b')' => depth -= 1,
                _ => {}
            }
            *pos += 1;
        }
        if depth != 0 {
            return None;
        }
        // `*pos`は閉じ括弧の直後を指している。中身は`[start, *pos-1)`。
        let inner = s.get(start..pos.saturating_sub(1)).unwrap_or("");
        return parse_calc_expr(inner.trim(), containing_width);
    }
    let start = *pos;
    while *pos < bytes.len() {
        let c = bytes[*pos];
        if c == b' ' || c == b'(' || c == b')' {
            break;
        }
        // 先頭以外の `+`/`-` は次の演算子の開始とみなしトークンを打ち切る
        // （先頭の `-` は `calc(-10px)` のような単項マイナスとして数値の
        // 一部に含める）。
        if (c == b'+' || c == b'-') && *pos > start {
            break;
        }
        *pos += 1;
    }
    let token = s.get(start..*pos).unwrap_or("");
    parse_calc_unit(token, containing_width)
}

/// `term := factor (('*' | '/') factor)*`。乗除算は加減算より優先度が高い。
fn parse_calc_term(s: &str, pos: &mut usize, containing_width: i32) -> Option<f32> {
    let bytes = s.as_bytes();
    let mut value = parse_calc_factor(s, pos, containing_width)?;
    loop {
        calc_skip_ws(bytes, pos);
        match bytes.get(*pos) {
            Some(b'*') => {
                *pos += 1;
                calc_skip_ws(bytes, pos);
                let rhs = parse_calc_factor(s, pos, containing_width)?;
                value *= rhs;
            }
            Some(b'/') => {
                *pos += 1;
                calc_skip_ws(bytes, pos);
                let rhs = parse_calc_factor(s, pos, containing_width)?;
                if rhs == 0.0 {
                    return None;
                }
                value /= rhs;
            }
            _ => break,
        }
    }
    Some(value)
}

/// `expr := term (('+' | '-') term)*`。任意個数の項を左結合で畳み込む
/// （以前は`+`/`-`/`*`をそれぞれ最大1回・2項までしか扱えず、`calc(100% -
/// 20px - 10px)`のような3項式や`calc(100% / 3)`のような除算、
/// `calc((100% - 20px) / 2)`のような括弧ネストが軒並み評価失敗していた。
/// 2026-07-16 発見・修正）。
fn parse_calc_expr(s: &str, containing_width: i32) -> Option<f32> {
    let bytes = s.as_bytes();
    let mut pos = 0usize;
    let mut value = parse_calc_term(s, &mut pos, containing_width)?;
    loop {
        calc_skip_ws(bytes, &mut pos);
        match bytes.get(pos) {
            Some(b'+') => {
                pos += 1;
                calc_skip_ws(bytes, &mut pos);
                let rhs = parse_calc_term(s, &mut pos, containing_width)?;
                value += rhs;
            }
            Some(b'-') => {
                pos += 1;
                calc_skip_ws(bytes, &mut pos);
                let rhs = parse_calc_term(s, &mut pos, containing_width)?;
                value -= rhs;
            }
            _ => break,
        }
    }
    calc_skip_ws(bytes, &mut pos);
    if pos != bytes.len() {
        // 末尾に解釈できない余りがある（構文エラー）。
        return None;
    }
    Some(value)
}

/// `calc()`式をpxへ評価する。四則演算・任意個数の項・丸括弧によるネストに
/// 対応する（`calc(Apx ± Bpx ± ...)`/`calc(A% * B)`/`calc(A / B)`/
/// `calc((A - B) / C)`等）。以前は`+`/`-`/`*`を1回ずつ・2項までしか扱えず
/// `/`（除算）が丸ごと未対応、括弧ネストも不可という限定的な実装だった。
pub fn eval_calc(expr: &str, containing_width: i32) -> Option<i32> {
    let inner = expr.trim();
    let inner = inner
        .strip_prefix("calc(")
        .and_then(|s| s.strip_suffix(')'))?;
    parse_calc_expr(inner.trim(), containing_width).map(|v| v as i32)
}

/// `min()` / `max()` / `clamp()` の引数を最上位のカンマだけで分割する。
/// 引数内に `calc()`/`min()`/`max()`/`clamp()` がネストしていても、その内側の
/// カンマは分割対象にしない（括弧の深さを追跡する）。
pub(crate) fn split_top_level_commas(s: &str) -> alloc::vec::Vec<&str> {
    let mut parts = alloc::vec::Vec::new();
    let bytes = s.as_bytes();
    let mut depth = 0i32;
    let mut start = 0usize;
    for (i, &b) in bytes.iter().enumerate() {
        match b {
            b'(' => depth += 1,
            b')' => depth -= 1,
            b',' if depth == 0 => {
                parts.push(s.get(start..i).unwrap_or("").trim());
                start = i + 1;
            }
            _ => {}
        }
    }
    parts.push(s.get(start..).unwrap_or("").trim());
    parts
}

/// 単一の `name: value` 宣言（`!important` 込み）をパースする。
/// 空の name/value や区切りの `:` が無い場合は `None`。
pub(crate) fn parse_one_declaration(raw: &str) -> Option<Declaration> {
    let mut kv = raw.splitn(2, ':');
    let name = kv.next()?.trim();
    let raw_value = kv.next()?.trim();
    let (value, important) = match raw_value.rfind('!') {
        Some(pos)
            if raw_value
                .get(pos + 1..)
                .unwrap_or("")
                .trim()
                .eq_ignore_ascii_case("important") =>
        {
            (raw_value.get(..pos).unwrap_or("").trim(), true)
        }
        _ => (raw_value, false),
    };
    if name.is_empty() || value.is_empty() {
        return None;
    }
    Some(Declaration {
        name: String::from(name),
        value: String::from(value),
        important,
    })
}

/// CSS Nesting のルール本体をパースする。トップレベル（このネストの深さ）の `;` で
/// 宣言を区切り、トップレベルの `{` はネストしたルールの開始とみなして対応する `}`
/// までを取り出し再帰する。ネストしたセレクタの各カンマ枝は、`&` を含めば親セレクタの
/// テキストで置換し、含まなければ親セレクタの後ろに半角スペースで連結する（子孫結合子
/// 扱い）。戻り値はこのレベル自身の宣言一覧（ネストしたルールは `out_rules` に積む）。
pub(crate) fn parse_nested_body(
    parent_selector_texts: &[String],
    body: &str,
    out_rules: &mut Vec<Rule>,
    layer: Option<usize>,
) -> Vec<Declaration> {
    let mut declarations = Vec::new();
    let chars: Vec<char> = body.chars().collect();
    let mut i = 0usize;
    let mut buf = String::new();
    while i < chars.len() {
        match chars[i] {
            '{' => {
                let nested_selector_text = buf.trim().to_string();
                buf.clear();
                // 対応する `}` を探す（ネストの深さを追跡）。
                let mut depth = 1i32;
                let start = i + 1;
                let mut j = start;
                while j < chars.len() && depth > 0 {
                    match chars[j] {
                        '{' => depth += 1,
                        '}' => depth -= 1,
                        _ => {}
                    }
                    if depth > 0 {
                        j += 1;
                    }
                }
                let inner_body: String = chars[start..j.min(chars.len())].iter().collect();
                i = j;
                if !nested_selector_text.is_empty() {
                    let mut resolved_texts: Vec<String> = Vec::new();
                    for nb in split_top_level_commas(&nested_selector_text) {
                        let nb = nb.trim();
                        if nb.is_empty() {
                            continue;
                        }
                        for parent in parent_selector_texts {
                            let resolved = if nb.contains('&') {
                                nb.replace('&', parent)
                            } else {
                                alloc::format!("{} {}", parent, nb)
                            };
                            resolved_texts.push(resolved);
                        }
                    }
                    let nested_selectors: Vec<Selector> = resolved_texts
                        .iter()
                        .filter_map(|s| parse_selector(s.trim()))
                        .collect();
                    let nested_decls =
                        parse_nested_body(&resolved_texts, &inner_body, out_rules, layer);
                    if !nested_selectors.is_empty() && !nested_decls.is_empty() {
                        out_rules.push(Rule {
                            selectors: nested_selectors,
                            declarations: nested_decls,
                            layer,
                            media_query: None,
                            container_query: None,
                        });
                    }
                }
            }
            ';' => {
                if let Some(d) = parse_one_declaration(&buf) {
                    declarations.push(d);
                }
                buf.clear();
            }
            c => buf.push(c),
        }
        i += 1;
    }
    // 末尾の `;` は省略可能なので、残った buf も最後の宣言として扱う。
    if let Some(d) = parse_one_declaration(&buf) {
        declarations.push(d);
    }
    declarations
}

/// 単一の長さ値（`10px` / `50%` / `calc(...)` など、四則演算を含まない1トークン、
/// もしくは `calc()`/`min()`/`max()`/`clamp()` の再帰評価）を px へ解決する。
pub(crate) fn eval_length_token(s: &str, containing_width: i32) -> Option<f32> {
    let t = s.trim();
    if t.starts_with("calc(") || t.starts_with("min(") || t.starts_with("max(") || t.starts_with("clamp(")
    {
        return eval_css_math(t, containing_width).map(|v| v as f32);
    }
    if let Some(n) = t.strip_suffix("px") {
        return n.trim().parse::<f32>().ok();
    }
    // `vh`/`vw`/`vmin`/`vmax`（丸ごと未対応だった。`min()`/`max()`/`clamp()`の
    // 引数解決だけを担うこの`eval_length_token`は`px`/`rem`/`em`/`%`の4種
    // のみ対応で、`eval_calc`（`calc()`本体。2026-07-16に同種の単位対応を
    // 追加済み）や`layout/values.rs`の`parse_px_like`とは別実装のため
    // 追従していなかった。`min(50vw, 300px)`/`clamp(10px, 5vw, 50px)`の
    // ような定番のレスポンシブサイズ指定で、ビューポート単位の引数が
    // 未知トークンとして黙って`filter_map`に弾かれ計算から抜け落ちて
    // いた（エラーにならず静かに1引数少ない`min`/`max`として計算される
    // ため気づきにくい）。2026-07-16 発見・実装。`vmin`は`in`判定より前に
    // 置く（`layout/values.rs`の`parse_px_like`と同じ順序制約）。
    if let Some(n) = t.strip_suffix("vh") {
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * h as f32);
    }
    if let Some(n) = t.strip_suffix("vw") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w as f32);
    }
    if let Some(n) = t.strip_suffix("vmin") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.min(h) as f32);
    }
    if let Some(n) = t.strip_suffix("vmax") {
        let w = crate::os_lib::layout::VIEWPORT_HINT_W.load(core::sync::atomic::Ordering::Relaxed);
        let h = crate::os_lib::layout::VIEWPORT_HINT_H.load(core::sync::atomic::Ordering::Relaxed);
        return n.trim().parse::<f32>().ok().map(|v| v / 100.0 * w.max(h) as f32);
    }
    if let Some(n) = t.strip_suffix("rem") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = t.strip_suffix("em") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = t.strip_suffix('%') {
        return n
            .trim()
            .parse::<f32>()
            .ok()
            .map(|v| v / 100.0 * containing_width as f32);
    }
    // 絶対長さ単位（丸ごと未対応だった。`parse_px_like`と同じ理由・同じ
    // `96px = 1in`基準の換算。2026-07-16 発見・実装）。
    if let Some(n) = t.strip_suffix("in") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0);
    }
    if let Some(n) = t.strip_suffix("cm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 2.54);
    }
    if let Some(n) = t.strip_suffix("mm") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 25.4);
    }
    if let Some(n) = t.strip_suffix("pt") {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 72.0);
    }
    if let Some(n) = t.strip_suffix("pc") {
        return n.trim().parse::<f32>().ok().map(|v| v * 16.0);
    }
    if let Some(n) = t.strip_suffix('q') {
        return n.trim().parse::<f32>().ok().map(|v| v * 96.0 / 101.6);
    }
    t.parse::<f32>().ok()
}

/// CSS の数式関数（`calc()` / `min()` / `max()` / `clamp()`）を px へ評価する。
/// `min()`/`max()` は任意個数の引数、`clamp(min, val, pref)` は3引数固定。
/// 引数はネストした calc()/min()/max()/clamp() も再帰的に評価する。
pub fn eval_css_math(expr: &str, containing_width: i32) -> Option<i32> {
    let t = expr.trim();
    if t.starts_with("calc(") {
        return eval_calc(t, containing_width);
    }
    if let Some(inner) = t.strip_prefix("min(").and_then(|s| s.strip_suffix(')')) {
        let vals: alloc::vec::Vec<f32> = split_top_level_commas(inner)
            .iter()
            .filter_map(|a| eval_length_token(a, containing_width))
            .collect();
        return vals
            .into_iter()
            .fold(None, |acc, v| Some(acc.map_or(v, |m: f32| m.min(v))))
            .map(|v| v as i32);
    }
    if let Some(inner) = t.strip_prefix("max(").and_then(|s| s.strip_suffix(')')) {
        let vals: alloc::vec::Vec<f32> = split_top_level_commas(inner)
            .iter()
            .filter_map(|a| eval_length_token(a, containing_width))
            .collect();
        return vals
            .into_iter()
            .fold(None, |acc, v| Some(acc.map_or(v, |m: f32| m.max(v))))
            .map(|v| v as i32);
    }
    if let Some(inner) = t.strip_prefix("clamp(").and_then(|s| s.strip_suffix(')')) {
        let parts = split_top_level_commas(inner);
        if parts.len() != 3 {
            return None;
        }
        let min_v = eval_length_token(parts[0], containing_width)?;
        let pref_v = eval_length_token(parts[1], containing_width)?;
        let max_v = eval_length_token(parts[2], containing_width)?;
        // clamp(MIN, PREF, MAX): MAX が MIN を下回る異常値でも破綻しないよう
        // 実効上限を MIN 以上に補正してから挟み込む。
        let effective_max = max_v.max(min_v);
        return Some(pref_v.clamp(min_v, effective_max) as i32);
    }
    None
}

// 簡易CSSパーサ（tag / #id / .class と宣言ブロックをサポート）