atmos/os_lib/layout/

grid.rs

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

/// 文字列が `subgrid` 構文であるかを判定する。
/// W3C CSS Grid 2: `subgrid <line-name-list>?`。
pub(crate) fn is_subgrid(s: &str) -> bool {
    let t = s.trim();
    if t.eq_ignore_ascii_case("subgrid") {
        return true;
    }
    if t.get(..7).is_some_and(|h| h.eq_ignore_ascii_case("subgrid")) && t.as_bytes().get(7).is_some_and(|b| b.is_ascii_whitespace()) {
        return true;
    }
    false
}

#[derive(Debug, Clone)]
pub(crate) struct SubgridContext {
    pub col_widths: Vec<i32>,
    pub col_gap: i32,
}

pub(crate) static SUBGRID_CTX: spin::Mutex<Option<SubgridContext>> = spin::Mutex::new(None);

pub(crate) fn set_subgrid_ctx(ctx: Option<SubgridContext>) -> Option<SubgridContext> {
    let mut lock = SUBGRID_CTX.lock();
    let prev = lock.clone();
    *lock = ctx;
    prev
}

pub(crate) fn get_subgrid_ctx() -> Option<SubgridContext> {
    SUBGRID_CTX.lock().clone()
}

/// `grid-template-columns` を解析して列幅 Vec を返す。
/// `repeat(N, W)` / `repeat(auto-fit, minmax(Npx, 1fr))` / `1fr 2fr` / 固定 px に対応。
pub(crate) fn parse_grid_template_columns(s: &str, avail_w: i32) -> Vec<i32> {
    parse_grid_template_columns_gap(s, avail_w, 0)
}

/// `parse_grid_template_columns` の列間 gap 考慮版。
///
/// 【2026-09-26 バグ修正】従来は gap を知らずに列幅を決めていたため、
/// `1fr 1fr; gap:4rem` で各列がコンテナの半分になり、gap の分だけ右へはみ出した。
/// CSS Grid 仕様どおり、(a) fr へ配る残り幅から列間 gap の合計を引き、
/// (b) `repeat(auto-fit|auto-fill, minmax(M, ..))` の列数を
/// `floor((幅 + gap) / (M + gap))` で決める（n 列 + (n-1) gap が幅に収まる最大の n）。
pub(crate) fn parse_grid_template_columns_gap(s: &str, avail_w: i32, gap: i32) -> Vec<i32> {
    let gap = gap.max(0);
    let s = s.trim();
    if s.is_empty() {
        return alloc::vec![avail_w];
    }
    // `repeat(N, W)` or `repeat(auto-fit, minmax(min_px, 1fr))`
    if let Some(inner) = s.strip_prefix("repeat(").and_then(|t| t.strip_suffix(')')) {
        if let Some((count_str, rest)) = inner.split_once(',') {
            let count_s = count_str.trim();
            let col_def = rest.trim();
            // minmax(Xpx, 1fr) → auto-fit では コンテナ幅から min で列数を決める。
            let min_w = if let Some(mm) = col_def
                .strip_prefix("minmax(")
                .and_then(|t| t.strip_suffix(')'))
            {
                mm.split_once(',')
                    .and_then(|(a, _)| resolve_track_tok_opt(a.trim(), avail_w))
                    .unwrap_or(200)
            } else {
                parse_px_like(col_def).unwrap_or(avail_w)
            };
            let n: usize = if count_s == "auto-fit" || count_s == "auto-fill" {
                (libm::floorf((avail_w + gap) as f32 / (min_w.max(1) + gap) as f32) as usize).max(1)
            } else {
                count_s.parse::<usize>().unwrap_or(1).max(1)
            };
            // 固定 px 列定義（`repeat(3,100px)`）はその幅を尊重。fr/minmax/% は均等割り。
            let is_fixed_px = !col_def.ends_with("fr")
                && !col_def.starts_with("minmax(")
                && !col_def.ends_with('%')
                && parse_px_like(col_def).is_some();
            let col_w = if is_fixed_px {
                parse_px_like(col_def).unwrap_or(1).max(1)
            } else {
                ((avail_w - gap * (n as i32 - 1)) / n as i32).max(1)
            };
            return (0..n).map(|_| col_w).collect();
        }
    }
    // スペース区切りのトークン（1fr / 2fr / 200px / % など）
    let tokens: alloc::vec::Vec<&str> = s.split_whitespace().collect();
    if tokens.is_empty() {
        return alloc::vec![avail_w];
    }
    // `%` トラック（例: `50% 1fr`）を avail_w 基準で px へ解決する。`parse_px_like` は
    // px/vh/vw/rem/em のみ対応し `%` を扱わないため（`repeat()`/`minmax()` 経由の
    // 固定px判定でも同様に `%` は別扱いされている、既存の `is_fixed_px` 参照）、
    // ここで専用に解決する。
    fn resolve_track_tok_opt(tok: &str, avail_w: i32) -> Option<i32> {
        if let Some(pct) = tok.strip_suffix('%') {
            return pct
                .trim()
                .parse::<f32>()
                .ok()
                .map(|p| round_f32_to_i32(avail_w as f32 * p / 100.0));
        }
        parse_px_like(tok)
    }
    fn resolve_track_tok(tok: &str, avail_w: i32) -> i32 {
        resolve_track_tok_opt(tok, avail_w).unwrap_or(0)
    }
    // fr 合計と固定幅を分けて残り幅を分配。
    let mut fixed_total = 0i32;
    let mut fr_total = 0.0f32;
    for tok in &tokens {
        if let Some(fr) = tok.strip_suffix("fr") {
            fr_total += fr.trim().parse::<f32>().unwrap_or(1.0);
        } else {
            fixed_total += resolve_track_tok(tok, avail_w);
        }
    }
    let gaps_total = gap * (tokens.len() as i32 - 1).max(0);
    let remaining = (avail_w - fixed_total - gaps_total).max(0);
    tokens
        .iter()
        .map(|tok| {
            if let Some(fr) = tok.strip_suffix("fr") {
                let f = fr.trim().parse::<f32>().unwrap_or(1.0);
                if fr_total > 0.0 {
                    round_f32_to_i32(remaining as f32 * f / fr_total)
                } else {
                    remaining
                }
            } else {
                resolve_track_tok(tok, avail_w)
            }
        })
        .collect()
}

/// グリッドトラック（行/列の 1 トラック）のサイズ種別。
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) enum GridTrack {
    Px(i32),
    Fr(f32),
    Auto,
    MinContent,
    MaxContent,
    FitContent(i32),
    /// minmax(min_px, max): max が fr なら伸長可能だが最低 min_px を保証。
    /// max が auto/px のときは Fr(0) 相当で扱い、行高さは内容 or max_px と min_px の間。
    MinMax {
        min_px: i32,
        max_fr: f32,
        max_px: i32,
        max_is_fr: bool,
        max_is_auto: bool,
    },
}

/// トップレベル（括弧の外）の空白でトークン分割する。`minmax(a, b)` / `repeat(n, x)`
/// の括弧内の空白では分割しない。`string_slice` lint 回避のため char_indices + get を使う。
pub(crate) fn split_top_level_ws(s: &str) -> Vec<&str> {
    let mut out = Vec::new();
    let mut depth = 0i32;
    let mut start = 0usize;
    let mut in_tok = false;
    for (i, ch) in s.char_indices() {
        match ch {
            '(' => depth += 1,
            ')' => depth -= 1,
            c if c.is_whitespace() && depth == 0 => {
                if in_tok {
                    if let Some(t) = s.get(start..i) {
                        out.push(t);
                    }
                    in_tok = false;
                }
                continue;
            }
            _ => {}
        }
        if !in_tok {
            start = i;
            in_tok = true;
        }
    }
    if in_tok {
        if let Some(t) = s.get(start..) {
            out.push(t);
        }
    }
    out
}

/// 単一トラック定義（`100px` / `2fr` / `auto` / `50%` / `minmax(min,max)`）を解釈。
/// base は % 解決と auto 折衝の基準サイズ。
pub(crate) fn parse_one_grid_track(tok: &str, base: i32) -> GridTrack {
    let tok = tok.trim();
    if tok.is_empty() || tok.eq_ignore_ascii_case("auto") {
        return GridTrack::Auto;
    }
    if tok.eq_ignore_ascii_case("min-content") {
        return GridTrack::MinContent;
    }
    if tok.eq_ignore_ascii_case("max-content") {
        return GridTrack::MaxContent;
    }
    if let Some(fit) = tok
        .strip_prefix("fit-content(")
        .and_then(|t| t.strip_suffix(')'))
    {
        let limit = match parse_length_value(Some(fit.trim())) {
            Some(LengthValue::Px(px)) => px.max(0),
            Some(LengthValue::Percent(p)) => round_f32_to_i32(base as f32 * p).max(0),
            _ => parse_px_like(fit.trim()).unwrap_or(base).max(0),
        };
        return GridTrack::FitContent(limit);
    }
    if let Some(fr) = tok.strip_suffix("fr") {
        return GridTrack::Fr(fr.trim().parse::<f32>().unwrap_or(1.0).max(0.0));
    }
    if let Some(mm) = tok
        .strip_prefix("minmax(")
        .and_then(|t| t.strip_suffix(')'))
    {
        // minmax(min, max): min を下限 px、max を上限（fr/px/auto）として保持。
        if let Some((a, b)) = mm.split_once(',') {
            let min_px = match parse_length_value(Some(a.trim())) {
                Some(LengthValue::Px(px)) => px.max(0),
                Some(LengthValue::Percent(p)) => round_f32_to_i32(base as f32 * p).max(0),
                _ => 0, // auto/min-content 等は 0 下限扱い
            };
            let bt = b.trim();
            if let Some(fr) = bt.strip_suffix("fr") {
                return GridTrack::MinMax {
                    min_px,
                    max_fr: fr.trim().parse::<f32>().unwrap_or(1.0).max(0.0),
                    max_px: 0,
                    max_is_fr: true,
                    max_is_auto: false,
                };
            }
            let (max_px, max_is_auto) = match parse_length_value(Some(bt)) {
                Some(LengthValue::Px(px)) => (px.max(0), false),
                Some(LengthValue::Percent(p)) => (round_f32_to_i32(base as f32 * p).max(0), false),
                _ => (0, true), // auto/max-content
            };
            return GridTrack::MinMax {
                min_px,
                max_fr: 0.0,
                max_px,
                max_is_fr: false,
                max_is_auto,
            };
        }
    }
    match parse_length_value(Some(tok)) {
        Some(LengthValue::Px(px)) => GridTrack::Px(px),
        Some(LengthValue::Percent(p)) => GridTrack::Px(round_f32_to_i32(base as f32 * p)),
        _ => GridTrack::Auto,
    }
}

/// `grid-template-rows` / `grid-template-columns` を GridTrack のリストへ展開。
/// `repeat(N, def)` / `repeat(auto-fit|auto-fill, def)` を展開する。base は %/auto-fit 用。
pub(crate) fn parse_grid_tracks(s: &str, base: i32) -> Vec<GridTrack> {
    let s = s.trim();
    if s.is_empty() {
        return Vec::new();
    }
    let mut out = Vec::new();
    for tok in split_top_level_ws(s) {
        if let Some(inner) = tok
            .strip_prefix("repeat(")
            .and_then(|t| t.strip_suffix(')'))
        {
            if let Some((count_str, rest)) = inner.split_once(',') {
                let count_s = count_str.trim();
                let track = parse_one_grid_track(rest.trim(), base);
                let n: usize = if count_s == "auto-fit" || count_s == "auto-fill" {
                    let min_w = match track {
                        GridTrack::Px(px) => px.max(1),
                        GridTrack::MinMax { min_px, .. } => min_px.max(1),
                        _ => 1,
                    };
                    (libm::floorf(base as f32 / min_w as f32) as usize).max(1)
                } else {
                    count_s.parse::<usize>().unwrap_or(1).max(1)
                };
                for _ in 0..n {
                    out.push(track);
                }
                continue;
            }
        }
        out.push(parse_one_grid_track(tok, base));
    }
    out
}

/// グリッドアイテムの 1 軸の配置を解決する。
/// `short`（grid-row / grid-column のショートハンド `a / b`）を優先し、無ければ
/// longhand（`*-start` / `*-end`）を読む。戻り値は (明示開始行0始まり, スパン)。
/// 明示開始が無い（auto）の場合は None。
pub(crate) fn grid_axis_placement(
    b: &LayoutBox,
    short: &str,
    start_p: &str,
    end_p: &str,
) -> (Option<usize>, usize) {
    let (sv, ev) = if let Some(v) = box_style_value(b, short) {
        if let Some((a, c)) = v.split_once('/') {
            (Some(String::from(a.trim())), Some(String::from(c.trim())))
        } else {
            (Some(String::from(v.trim())), None)
        }
    } else {
        (
            box_style_value(b, start_p).map(|s| String::from(s.trim())),
            box_style_value(b, end_p).map(|s| String::from(s.trim())),
        )
    };
    let mut start: Option<usize> = None;
    let mut span: usize = 1;
    if let Some(sv) = &sv {
        if let Some(n) = sv.strip_prefix("span ") {
            span = n.trim().parse::<usize>().unwrap_or(1).max(1);
        } else if let Ok(line) = sv.parse::<i32>() {
            if line >= 1 {
                start = Some((line - 1) as usize);
            }
        }
    }
    if let Some(ev) = &ev {
        if let Some(n) = ev.strip_prefix("span ") {
            span = n.trim().parse::<usize>().unwrap_or(1).max(1);
        } else if let Ok(eline) = ev.parse::<i32>() {
            if let Some(s0) = start {
                let e0 = (eline - 1).max(0) as usize;
                if e0 > s0 {
                    span = e0 - s0;
                }
            }
        }
    }
    (start, span)
}

/// `grid-template-areas` を解析する。各文字列リテラル（クォートされた1行）が1グリッド行、
/// 空白区切りのトークンがその行の各列のセル名になる。`.` は未使用セル（名前なし）扱い。
/// 例: `"header header" "sidebar content"` → [["header","header"],["sidebar","content"]]
pub(crate) fn parse_grid_template_areas(s: &str) -> Vec<Vec<String>> {
    let mut rows = Vec::new();
    let mut chars = s.chars().peekable();
    while let Some(c) = chars.next() {
        if c == '"' || c == '\'' {
            let quote = c;
            let mut row_str = String::new();
            for c2 in chars.by_ref() {
                if c2 == quote {
                    break;
                }
                row_str.push(c2);
            }
            let row: Vec<String> = row_str
                .split_whitespace()
                .map(String::from)
                .collect();
            if !row.is_empty() {
                rows.push(row);
            }
        }
    }
    rows
}

/// `template_areas` 内で `name` という名前のセルが占める矩形のバウンディングボックスを返す。
/// (row_start, col_start, row_span, col_span)（いずれも0始まり）。`.` は名前なしセルなので対象外。
pub(crate) fn find_grid_area(
    template_areas: &[Vec<String>],
    name: &str,
) -> Option<(usize, usize, usize, usize)> {
    if name == "." {
        return None;
    }
    let mut min_r = usize::MAX;
    let mut max_r = 0usize;
    let mut min_c = usize::MAX;
    let mut max_c = 0usize;
    let mut found = false;
    for (r, row) in template_areas.iter().enumerate() {
        for (c, cell) in row.iter().enumerate() {
            if cell == name {
                found = true;
                min_r = min_r.min(r);
                max_r = max_r.max(r);
                min_c = min_c.min(c);
                max_c = max_c.max(c);
            }
        }
    }
    if !found {
        return None;
    }
    Some((min_r, min_c, max_r - min_r + 1, max_c - min_c + 1))
}

/// occupancy 行を必要分まで確保（n_cols 幅の false 行を追加）。
pub(crate) fn grid_ensure_row(occ: &mut Vec<Vec<bool>>, r: usize, n_cols: usize) {
    while occ.len() <= r {
        occ.push(alloc::vec![false; n_cols]);
    }
}

/// `grid-auto-flow: column` が明示列数を超えて新しい列を作った際、既存の全行の
/// occupancy 幅を min_cols まで広げる（新規に作る行は grid_ensure_row 側で
/// 正しい幅で作られるため対象外。既存行だけ広げれば足りる）。
pub(crate) fn grid_ensure_col(occ: &mut [Vec<bool>], min_cols: usize) {
    for row in occ.iter_mut() {
        while row.len() < min_cols {
            row.push(false);
        }
    }
}

/// (r,c) から row_span×col_span の矩形が全て空いているか。
pub(crate) fn grid_cells_free(
    occ: &[Vec<bool>],
    r: usize,
    c: usize,
    row_span: usize,
    col_span: usize,
    n_cols: usize,
) -> bool {
    if c + col_span > n_cols {
        return false;
    }
    for rr in r..r + row_span {
        let Some(row) = occ.get(rr) else { continue };
        for cc in c..c + col_span {
            if row.get(cc).copied().unwrap_or(false) {
                return false;
            }
        }
    }
    true
}

/// (r,c) から row_span×col_span を占有済みにする。
pub(crate) fn grid_mark(
    occ: &mut [Vec<bool>],
    r: usize,
    c: usize,
    row_span: usize,
    col_span: usize,
    n_cols: usize,
) {
    for rr in r..r + row_span {
        let Some(row) = occ.get_mut(rr) else { continue };
        for cc in c..(c + col_span).min(n_cols) {
            if let Some(cell) = row.get_mut(cc) {
                *cell = true;
            }
        }
    }
}

/// 列インデックス col の左端 x オフセット（列幅 + col_gap の累積）。
pub(crate) fn grid_col_x(col_widths: &[i32], col_gap: i32, col: usize) -> i32 {
    let mut x = 0i32;
    for (i, w) in col_widths.iter().enumerate() {
        if i >= col {
            break;
        }
        x += w + col_gap;
    }
    x
}

/// col から col_span 列ぶんの合計幅（内側の col_gap を含む）。
pub(crate) fn grid_span_width(col_widths: &[i32], col_gap: i32, col: usize, col_span: usize) -> i32 {
    let n = col_widths.len();
    if n == 0 {
        return 1;
    }
    let end = (col + col_span).min(n);
    let start = col.min(n.saturating_sub(1));
    let mut w = 0i32;
    for item in col_widths.iter().take(end).skip(start) {
        w += *item;
    }
    w += (end.saturating_sub(start).saturating_sub(1) as i32) * col_gap;
    w.max(1)
}


/// `grid-template-columns` の各列の fr 係数（fr でない列・暗黙列は `None`）。
///
/// `expand_flexible_tracks` で「自動最小（min-content）を持つ fr 列」を
/// 見分けるのに使う。`minmax(固定, 1fr)` は下限が固定なので対象外（`None`）。
pub(crate) fn flex_factors(template: &str, n: usize) -> Vec<Option<f32>> {
    let fr_of = |tok: &str| -> Option<f32> {
        let f = tok.trim().strip_suffix("fr")?.trim().parse::<f32>().ok()?;
        (f > 0.0).then_some(f)
    };
    let t = template.trim();
    let mut out: Vec<Option<f32>> =
        if let Some(inner) = t.strip_prefix("repeat(").and_then(|x| x.strip_suffix(')')) {
            let f = inner.split_once(',').and_then(|(_, def)| fr_of(def));
            alloc::vec![f; n]
        } else {
            t.split_whitespace().map(fr_of).collect()
        };
    out.resize(n, None);
    out
}

/// fr 列の自動最小を考慮して列幅を配り直す（CSS Grid §12.7.1「fr の大きさを求める」の簡略版）。
///
/// 【2026-10-04】`1fr` は `minmax(auto, 1fr)` で、列は中身の最小幅（min-content）より
/// 狭くならない。従来は文字列だけで幅を配っていたため、sugi-lab.net トップの
/// `.about-content{grid-template-columns:1fr 1fr}` が Chrome（左 443.9・右 376.1）と違い
/// 410/410 の等分になり、左列の統計カードがはみ出していた。
///
/// - `base`: 文字列から配った列幅（fr 列は残り幅を係数比で配った値）
/// - `flex`: 各列の fr 係数（`flex_factors`）。`None` の列は変えない
/// - `mins`: 各列の最小幅（その列だけに入る要素の min-content の最大）
///
/// 最小幅を下回る fr 列をその幅に固定し、残りを固定していない fr 列へ係数比で配る。
/// 固定したことで別の列が足りなくなれば繰り返す。全部固定して収まらなければ
/// 最小幅のまま（はみ出す）。満たしていれば `base` をそのまま返す。
pub(crate) fn expand_flexible_tracks(base: &[i32], flex: &[Option<f32>], mins: &[i32]) -> Vec<i32> {
    let n = base.len();
    let f = |i: usize| flex.get(i).copied().flatten();
    let m = |i: usize| mins.get(i).copied().unwrap_or(0).max(0);
    let flex_idx: Vec<usize> = (0..n).filter(|&i| f(i).is_some()).collect();
    if flex_idx.iter().all(|&i| base[i] >= m(i)) {
        return base.to_vec();
    }
    let space: i32 = flex_idx.iter().map(|&i| base[i]).sum();
    let mut frozen = alloc::vec![false; n];
    let mut hyp;
    loop {
        let used: i32 = flex_idx.iter().filter(|&&i| frozen[i]).map(|&i| m(i)).sum();
        let sum_f: f32 = flex_idx
            .iter()
            .filter(|&&i| !frozen[i])
            .filter_map(|&i| f(i))
            .sum();
        hyp = if sum_f > 0.0 { (space - used).max(0) as f32 / sum_f } else { 0.0 };
        let mut changed = false;
        for &i in &flex_idx {
            if !frozen[i] && f(i).unwrap_or(0.0) * hyp < m(i) as f32 {
                frozen[i] = true;
                changed = true;
            }
        }
        if !changed {
            break;
        }
    }
    let mut out = base.to_vec();
    for &i in &flex_idx {
        out[i] = if frozen[i] {
            m(i)
        } else {
            round_f32_to_i32(f(i).unwrap_or(0.0) * hyp)
        };
    }
    // 丸めの端数で合計がずれないよう、固定していない最後の fr 列で吸収する
    // （全部固定してはみ出す場合は合わせない）。
    if let Some(&last) = flex_idx.iter().rev().find(|&&i| !frozen[i]) {
        let total: i32 = flex_idx.iter().map(|&i| out[i]).sum();
        out[last] = (out[last] + space - total).max(0);
    }
    out
}

/// グリッド容器の内在幅を求めるときの列数。
///
/// `repeat(N, ..)` は N、空白区切りはトークン数。`auto-fit`/`auto-fill` は
/// 内在幅の計測では 1 回の繰り返しとして数える（CSS Grid §7.2.3.2）。未指定は 1。
pub(crate) fn grid_column_count_for_intrinsic(template: &str) -> usize {
    let t = template.trim();
    if t.is_empty() {
        return 1;
    }
    if let Some(inner) = t.strip_prefix("repeat(").and_then(|x| x.strip_suffix(')')) {
        let count = inner.split_once(',').map(|(c, _)| c.trim()).unwrap_or("1");
        return count.parse::<usize>().unwrap_or(1).max(1);
    }
    split_top_level_ws(t).len().max(1)
}

/// グリッド容器の内在幅 (min-content, max-content)。
///
/// 【2026-10-04】従来は一般のブロックと同じく「子の最小幅の最大」で集計しており、
/// 列が横に並ぶことを考えていなかった（統計カード 3 枚のグリッドの min-content が
/// カード 1 枚分になった）。列ごとに項目の最大を取り、列の合計 + 列間 gap にする。
///
/// - `fixed`: 各列が固定幅ならその px（fr/auto は `None`）
/// - `items`: (列番号, 余白込みの min-content, 余白込みの max-content)。1 列にだけ入る項目
pub(crate) fn grid_intrinsic_widths(
    n_cols: usize,
    fixed: &[Option<i32>],
    items: &[(usize, i32, i32)],
    gap: i32,
) -> (i32, i32) {
    if n_cols == 0 {
        return (0, 0);
    }
    let mut mins = alloc::vec![0i32; n_cols];
    let mut maxs = alloc::vec![0i32; n_cols];
    for &(c, mn, mx) in items {
        if c < n_cols {
            mins[c] = mins[c].max(mn.max(0));
            maxs[c] = maxs[c].max(mx.max(0));
        }
    }
    for c in 0..n_cols {
        if let Some(px) = fixed.get(c).copied().flatten() {
            mins[c] = px.max(0);
            maxs[c] = px.max(0);
        }
    }
    let gaps = gap.max(0) * (n_cols as i32 - 1);
    let minc = mins.iter().sum::<i32>() + gaps;
    let maxc = maxs.iter().sum::<i32>() + gaps;
    (minc, maxc.max(minc))
}