atmos/os_lib/css/

container_query.rs

//! CSS コンテナクエリ（`@container`）の条件評価（純粋モジュール）。
//!
//! `@media` との決定的な違いは**基準がビューポートではなくコンテナ**である
//! こと。`@media` はグローバルなビューポート寸法を見ればよいが、
//! `@container` は「その要素にとっての問い合わせコンテナ」の寸法に依存する
//! ため、評価にはコンテナ寸法を**引数で**渡す必要がある。
//! グローバル状態に触らないので、ホスト側から検証できる。
//!
//! # 対応する構文
//!
//! - `@container (min-width: 400px)`
//! - `@container (width > 400px)` … レンジ構文
//! - `@container card (min-width: 400px)` … 名前付きコンテナ
//! - `and` / `or` / `not` の論理結合
//!
//! # 未対応（意図的）
//!
//! - スタイルクエリ（`@container style(--foo: bar)`）
//! - `inline-size`/`block-size` の書字方向依存（横書き前提で `width`/`height`
//!   と同一視する）
//! - `aspect-ratio` / `orientation`

extern crate alloc;
use alloc::string::String;

/// 問い合わせコンテナの寸法（px）。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ContainerSize {
    pub width: i32,
    pub height: i32,
}

/// `@container` のプレリュードを「コンテナ名」と「条件式」へ分ける。
///
/// 名前は省略可能で、その場合は最も近い祖先の問い合わせコンテナが対象。
pub fn split_name_and_condition(prelude: &str) -> (Option<String>, String) {
    let s = prelude.trim();
    if s.is_empty() {
        return (None, String::new());
    }
    let first = s.split_whitespace().next().unwrap_or("");
    // 先頭トークンが識別子（`(` でも `not` でもない）ならコンテナ名。
    if !first.starts_with('(') && !first.eq_ignore_ascii_case("not") {
        // `get()` で境界安全に切る（`first` は空白区切りなので通常は
        // 境界上だが、`&str` の添字は UTF-8 境界を外すとパニックするため
        // 常に安全側の API を使う）。
        let rest = s.get(first.len()..).unwrap_or("").trim();
        return (Some(String::from(first)), String::from(rest));
    }
    (None, String::from(s))
}

/// 条件式がコンテナ寸法に対して真かを判定する。
///
/// 評価順序は CSS の論理演算に合わせ `or` → `and` → `not`。
/// 解釈できない条件は **false**（＝当てない）。`@media` は互換性のため
/// 不明な条件を true へ倒す箇所があるが、コンテナクエリは新しい構文で
/// あり、解釈できないものを適用すると意図しないスタイルが当たるため、
/// 安全側は「当てない」になる。
pub fn condition_matches(cond: &str, size: ContainerSize) -> bool {
    let s = cond.trim();
    if s.is_empty() {
        return false;
    }
    // `or` が最も弱い結合。
    if let Some(parts) = split_top_level(s, " or ") {
        return parts.iter().any(|p| condition_matches(p, size));
    }
    if let Some(parts) = split_top_level(s, " and ") {
        return parts.iter().all(|p| condition_matches(p, size));
    }
    if let Some(rest) = strip_kw_prefix(s, "not") {
        return !condition_matches(rest, size);
    }
    // 括弧をひと皮むく。中に論理演算が残っていれば再帰で拾う。
    if s.starts_with('(') && s.ends_with(')') && s.len() >= 2 {
        let Some(inner) = s.get(1..s.len() - 1) else {
            return false;
        };
        if inner.contains(" and ") || inner.contains(" or ") || starts_with_kw(inner, "not") {
            return condition_matches(inner, size);
        }
        return eval_single(inner.trim(), size);
    }
    eval_single(s, size)
}

/// 括弧の深さを考慮してトップレベルの区切りで分割する。区切りが無ければ `None`。
fn split_top_level<'a>(s: &'a str, sep: &str) -> Option<alloc::vec::Vec<&'a str>> {
    let bytes = s.as_bytes();
    let sep_bytes = sep.as_bytes();
    let mut depth = 0i32;
    let mut parts = alloc::vec::Vec::new();
    let mut start = 0usize;
    let mut i = 0usize;
    while i < bytes.len() {
        match bytes[i] {
            b'(' => depth += 1,
            b')' => depth -= 1,
            _ => {}
        }
        if depth == 0
            && i + sep_bytes.len() <= bytes.len()
            && bytes.get(i..i + sep_bytes.len()) == Some(sep_bytes)
        {
            // 区切りは ASCII なので、その前後は必ず UTF-8 境界になる。
            // それでも `get()` で受けてパニック経路を残さない。
            if let Some(part) = s.get(start..i) {
                parts.push(part.trim());
            }
            i += sep_bytes.len();
            start = i;
            continue;
        }
        i += 1;
    }
    if parts.is_empty() {
        return None;
    }
    if let Some(tail) = s.get(start..) {
        parts.push(tail.trim());
    }
    Some(parts)
}

/// 先頭がキーワード（後ろに空白か `(` が続く）か。
fn starts_with_kw(s: &str, kw: &str) -> bool {
    let s = s.trim_start();
    s.get(..kw.len()).is_some_and(|h| h.eq_ignore_ascii_case(kw))
        && s.get(kw.len()..)
            .and_then(|r| r.chars().next())
            .is_some_and(|c| c.is_whitespace() || c == '(')
}

/// 先頭のキーワードを取り除いた残りを返す。
fn strip_kw_prefix<'a>(s: &'a str, kw: &str) -> Option<&'a str> {
    if starts_with_kw(s, kw) {
        s.trim_start().get(kw.len()..).map(|r| r.trim())
    } else {
        None
    }
}

/// 単一条件（`min-width: 400px` / `width > 400px` 等）を評価する。
fn eval_single(cond: &str, size: ContainerSize) -> bool {
    let c = cond.trim().trim_matches(|ch| ch == '(' || ch == ')').trim();
    if c.is_empty() {
        return false;
    }
    // `min-`/`max-` 前置構文。`inline-size`/`block-size` は横書き前提で
    // `width`/`height` と同一視する。
    for (prefix, is_w, is_min) in [
        ("min-width:", true, true),
        ("max-width:", true, false),
        ("min-height:", false, true),
        ("max-height:", false, false),
        ("min-inline-size:", true, true),
        ("max-inline-size:", true, false),
        ("min-block-size:", false, true),
        ("max-block-size:", false, false),
    ] {
        if let Some(rest) = strip_ci_prefix(c, prefix) {
            let v = if is_w { size.width } else { size.height };
            return parse_px(rest).is_some_and(|px| if is_min { v >= px } else { v <= px });
        }
    }
    // レンジ構文。長い演算子から先に見ないと `>=` が `>` と誤解釈される。
    for op in [">=", "<=", ">", "<", "="] {
        if let Some((lhs, rhs)) = c.split_once(op) {
            let axis = lhs.trim().to_ascii_lowercase();
            let v = match axis.as_str() {
                "width" | "inline-size" => size.width,
                "height" | "block-size" => size.height,
                _ => return false,
            };
            let Some(px) = parse_px(rhs) else {
                return false;
            };
            return match op {
                ">=" => v >= px,
                "<=" => v <= px,
                ">" => v > px,
                "<" => v < px,
                _ => v == px,
            };
        }
    }
    // 解釈できない条件は当てない。
    false
}

/// 大文字小文字を無視して前置詞を剥がす。`min-width :` のような空白も許容。
fn strip_ci_prefix<'a>(s: &'a str, prefix: &str) -> Option<&'a str> {
    if s.get(..prefix.len())
        .is_some_and(|h| h.eq_ignore_ascii_case(prefix))
    {
        return s.get(prefix.len()..);
    }
    // `min-width :` のように名前と `:` の間へ空白が入る書き方にも耐える。
    let name = prefix.trim_end_matches(':');
    let s_trim = s.trim_start();
    if s_trim
        .get(..name.len())
        .is_some_and(|h| h.eq_ignore_ascii_case(name))
    {
        let rest = s_trim.get(name.len()..).unwrap_or("").trim_start();
        if let Some(after) = rest.strip_prefix(':') {
            return Some(after);
        }
    }
    None
}

/// `400px` / `400` を px として読む。解釈できなければ `None`。
fn parse_px(s: &str) -> Option<i32> {
    let t = s.trim().trim_end_matches("px").trim();
    if t.is_empty() {
        return None;
    }
    t.parse::<f32>()
        .ok()
        .filter(|v| v.is_finite())
        .map(|v| v as i32)
}