atmos/os_lib/layout/

grid.rs

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

/// `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)]
pub(crate) enum GridTrack {
    Px(i32),
    Fr(f32),
    Auto,
    /// 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 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)
}