atmos/os_lib/web_engine/

helpers.rs

// web_engine/helpers.rs - Standalone utility functions

use alloc::string::String;
use alloc::vec::Vec;

pub(super) fn ascii_eq_ignore_case(a: &[u8], b: &[u8]) -> bool {
    if a.len() != b.len() {
        return false;
    }
    for i in 0..a.len() {
        if !a[i].eq_ignore_ascii_case(&b[i]) {
            return false;
        }
    }
    true
}

/// font-size の値をパース。実体は自己完結モジュール `css_units` にあり、
/// 仕様は `tests/src/test_css_units.rs` に異常系込みで固定してある。
pub(crate) use super::css_units::parse_font_size;

pub fn hash_str(s: &str) -> u32 {
    let mut h = 5381u32;
    for c in s.bytes() {
        h = h.wrapping_shl(5).wrapping_add(h).wrapping_add(c as u32);
    }
    h
}

pub fn url_encode(s: &str) -> String {
    let mut encoded = String::new();
    for b in s.as_bytes() {
        match *b {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                encoded.push(*b as char);
            }
            b' ' => {
                encoded.push('+');
            }
            _ => {
                encoded.push_str(&alloc::format!("%{:02X}", b));
            }
        }
    }
    encoded
}

pub(super) fn resolve_relative_path(base_path: &str, rel_path: &str) -> String {
    // 【2026-08-27】組み立ての本体は純粋モジュールへ切り出した。
    // `data:` URI・フラグメント・プロトコル相対 URL を壊していたため
    // （詳細と試験は `rel_path.rs` / `test_rel_path.rs`）。
    super::rel_path::resolve_relative_path(base_path, rel_path)
}

/// list-style-type を抽出。`list-style-type` 優先、無ければ `list-style` ショートハンドから
/// 既知のキーワードを拾う。未指定は空（デフォルトのマーカー挙動）。
pub(super) fn extract_list_style(styled: &crate::os_lib::css::StyledNode) -> super::ListStyleType {
    if let Some(t) = styled.specified_values.get("list-style-type") {
        return super::ListStyleType::parse(t);
    }
    if let Some(s) = styled.specified_values.get("list-style") {
        for tok in s.split_whitespace() {
            // `ListStyleType::parse` に直接委譲することで、longhand と同じキーワード集合
            // （upper-alpha/lower-roman 等を含む）を自動的にサポートする。`inside`/`outside`/
            // `url(...)` 等の list-style-type ではないトークンは Unset になるので読み飛ばす。
            let parsed = super::ListStyleType::parse(tok);
            if parsed != super::ListStyleType::Unset {
                return parsed;
            }
        }
    }
    super::ListStyleType::Unset
}

/// list-style-position を抽出。`list-style-position` 優先、無ければ `list-style` ショートハンド
/// から拾う。既定は "outside"（true を返せば inside）。
pub(super) fn extract_list_style_inside(styled: &crate::os_lib::css::StyledNode) -> bool {
    if let Some(p) = styled.specified_values.get("list-style-position") {
        return p.trim().eq_ignore_ascii_case("inside");
    }
    if let Some(s) = styled.specified_values.get("list-style") {
        for tok in s.split_whitespace() {
            if tok.eq_ignore_ascii_case("inside") {
                return true;
            }
        }
    }
    false
}

/// `list-style-image: url(...)` を抽出。`list-style-image` 優先、無ければ `list-style`
/// ショートハンド中の `url(...)` トークンを拾う。未指定/`none` は空文字（従来通り
/// list-style-type のグリフを使う）。
pub(super) fn extract_list_style_image(styled: &crate::os_lib::css::StyledNode) -> String {
    if let Some(v) = styled.specified_values.get("list-style-image") {
        if v.trim().eq_ignore_ascii_case("none") {
            return String::new();
        }
        if let Some(path) = extract_url_path(v) {
            return path;
        }
    }
    if let Some(s) = styled.specified_values.get("list-style") {
        if let Some(path) = extract_url_path(s) {
            return path;
        }
    }
    String::new()
}

/// `background-size` を解析。未指定/解析不能なら Stretch（従来互換の全面引き伸ばし）。
pub(super) fn parse_bg_size(v: Option<&str>) -> super::BgSizeMode {
    use super::{BgSizeMode, BgSizeVal};
    fn parse_val(tok: &str) -> BgSizeVal {
        let t = tok.trim();
        if t == "auto" {
            BgSizeVal::Auto
        } else if let Some(pct) = t.strip_suffix('%') {
            pct.parse::<f32>()
                .map(|p| BgSizeVal::Percent(p / 100.0))
                .unwrap_or(BgSizeVal::Auto)
        } else if let Some(px) = t.strip_suffix("px") {
            px.parse::<i32>().map(BgSizeVal::Px).unwrap_or(BgSizeVal::Auto)
        } else {
            BgSizeVal::Auto
        }
    }
    let Some(v) = v else {
        return BgSizeMode::Stretch;
    };
    let v = v.trim().to_ascii_lowercase();
    match v.as_str() {
        "cover" => BgSizeMode::Cover,
        "contain" => BgSizeMode::Contain,
        "" | "auto" => BgSizeMode::Stretch,
        _ => {
            let toks: Vec<&str> = v.split_whitespace().collect();
            match toks.len() {
                1 => BgSizeMode::Explicit(parse_val(toks[0]), BgSizeVal::Auto),
                2 => BgSizeMode::Explicit(parse_val(toks[0]), parse_val(toks[1])),
                _ => BgSizeMode::Stretch,
            }
        }
    }
}

/// `background-repeat` を解析。(repeat_x, repeat_y) を返す。未指定は
/// (Repeat, Repeat)（CSS既定）。`repeat-x`/`repeat-y` は片軸 no-repeat のショートハンド。
/// `<x> <y>` の2値構文（例: `repeat space`, `round no-repeat`）にも対応する。
pub(crate) fn parse_bg_repeat(v: Option<&str>) -> (super::BgRepeatMode, super::BgRepeatMode) {
    use super::BgRepeatMode;
    fn parse_one(t: &str) -> BgRepeatMode {
        match t {
            "no-repeat" => BgRepeatMode::NoRepeat,
            "space" => BgRepeatMode::Space,
            "round" => BgRepeatMode::Round,
            _ => BgRepeatMode::Repeat,
        }
    }
    let Some(v) = v else {
        return (BgRepeatMode::Repeat, BgRepeatMode::Repeat);
    };
    let v = v.trim().to_ascii_lowercase();
    match v.as_str() {
        "no-repeat" => (BgRepeatMode::NoRepeat, BgRepeatMode::NoRepeat),
        "repeat-x" => (BgRepeatMode::Repeat, BgRepeatMode::NoRepeat),
        "repeat-y" => (BgRepeatMode::NoRepeat, BgRepeatMode::Repeat),
        "repeat" => (BgRepeatMode::Repeat, BgRepeatMode::Repeat),
        _ => {
            let toks: Vec<&str> = v.split_whitespace().collect();
            match toks.len() {
                2 => (parse_one(toks[0]), parse_one(toks[1])),
                1 => {
                    let m = parse_one(toks[0]);
                    (m, m)
                }
                _ => (BgRepeatMode::Repeat, BgRepeatMode::Repeat),
            }
        }
    }
}

/// `background-position` を解析。(x_frac, y_frac) の 0.0-1.0 アンカーを返す。未指定は (0,0)。
pub(super) fn parse_bg_position(v: Option<&str>) -> (f32, f32) {
    fn parse_axis(tok: &str, is_x: bool) -> f32 {
        let t = tok.trim();
        match t {
            "left" | "top" => 0.0,
            "center" => 0.5,
            "right" | "bottom" => 1.0,
            _ => {
                if let Some(pct) = t.strip_suffix('%') {
                    pct.parse::<f32>().map(|p| p / 100.0).unwrap_or(0.0)
                } else {
                    let _ = is_x;
                    0.0
                }
            }
        }
    }
    let Some(v) = v else {
        return (0.0, 0.0);
    };
    let toks: Vec<&str> = v.split_whitespace().collect();
    match toks.len() {
        1 => (parse_axis(toks[0], true), 0.5),
        2 => {
            // CSS では `top left` のように y軸→x軸の逆順キーワード指定も許される
            // （`left top` と同じ意味）。以前は常に「1つ目=x, 2つ目=y」の位置決め打ちだったため、
            // `top right` のような逆順+非対称な組み合わせで x/y が入れ替わって誤った位置になる
            // バグがあった（`top`/`bottom` と `left`/`right` がどちらも 0.0/1.0 に丸め込まれる
            // ため `top left`/`left top` のような対称な組み合わせでは症状が隠れていた）。
            let first_is_y_kw = matches!(toks[0].trim(), "top" | "bottom");
            let second_is_x_kw = matches!(toks[1].trim(), "left" | "right");
            if first_is_y_kw || second_is_x_kw {
                (parse_axis(toks[1], true), parse_axis(toks[0], false))
            } else {
                (parse_axis(toks[0], true), parse_axis(toks[1], false))
            }
        }
        _ => (0.0, 0.0),
    }
}

/// `text-decoration` ショートハンド（`underline wavy red` のように line/style/color を
/// 空白区切り任意順で並べられる）を解析する。戻り値: (underline指定, line-through指定,
/// overline指定, none指定, style, color)。line キーワードが無いトークン列の場合、対応する
/// bool は false のまま返す（呼び出し側で「未指定」と区別せず既存状態を保つかは呼び出し側の
/// 判断に委ねる）。`blink` は認識するのみで描画には反映しない（点滅テキストは非対応）。
pub(crate) fn parse_text_decoration_shorthand(
    value: &str,
) -> (bool, bool, bool, bool, Option<String>, Option<u32>) {
    let v = value.trim().to_lowercase();
    if v == "none" {
        return (false, false, false, true, None, None);
    }
    let mut underline = false;
    let mut line_through = false;
    let mut overline = false;
    let mut style: Option<String> = None;
    let mut color: Option<u32> = None;
    for tok in v.split_whitespace() {
        match tok {
            "underline" => underline = true,
            "line-through" => line_through = true,
            "overline" => overline = true,
            "blink" => {} // 点滅テキストは非対応につき認識のみ
            "solid" | "dotted" | "dashed" | "wavy" | "double" => style = Some(String::from(tok)),
            _ => {
                if let Some(c) = crate::os_lib::css::parse_color(tok) {
                    color = Some(c);
                }
            }
        }
    }
    (underline, line_through, overline, false, style, color)
}

/// `outline`（ショートハンド or 個別プロパティ）から (color, width_px, style) を抽出する。
/// style は `dashed`/`dotted` のみ区別し、それ以外（solid 含む）は "solid" 扱いにする
/// 簡略実装。`outline-style:none` や幅0は無効。
pub(super) fn parse_outline(styled: &crate::os_lib::css::StyledNode) -> Option<(u32, i32, String)> {
    fn parse_width_tok(t: &str) -> Option<i32> {
        match t {
            "thin" => Some(1),
            "medium" => Some(3),
            "thick" => Some(5),
            _ => t
                .strip_suffix("px")
                .and_then(|n| n.trim().parse::<i32>().ok()),
        }
    }
    let mut color: Option<u32> = None;
    let mut width: Option<i32> = None;
    let mut has_none_style = false;
    let mut style = String::from("solid");

    if let Some(w) = styled.specified_values.get("outline-width") {
        width = parse_width_tok(w.trim());
    }
    if let Some(c) = styled.specified_values.get("outline-color") {
        color = crate::os_lib::css::parse_color(c);
    }
    if let Some(s) = styled.specified_values.get("outline-style") {
        let s_l = s.trim().to_lowercase();
        // `hidden` は `none` と同様に描画しない（CSS3 outline-style の仕様通り。
        // border-style の `hidden` 縮退と同じ方針）。groove/ridge/inset/outset は
        // 立体的な描画が非対応なので border-style と同様 solid へ縮退させる。
        if s_l == "none" || s_l == "hidden" {
            has_none_style = true;
        } else if matches!(s_l.as_str(), "dashed" | "dotted") {
            style = s_l;
        } else if matches!(s_l.as_str(), "groove" | "ridge" | "inset" | "outset") {
            style = String::from("solid");
        }
    }
    if let Some(shorthand) = styled.specified_values.get("outline") {
        let s = shorthand.trim();
        if s.eq_ignore_ascii_case("none") {
            has_none_style = true;
        } else {
            for tok in s.split_whitespace() {
                if let Some(w) = parse_width_tok(tok) {
                    width = width.or(Some(w));
                } else if let Some(c) = crate::os_lib::css::parse_color(tok) {
                    color = color.or(Some(c));
                } else if tok.eq_ignore_ascii_case("hidden") {
                    has_none_style = true;
                } else if matches!(tok, "dashed" | "dotted") {
                    style = String::from(tok);
                } else if matches!(tok, "groove" | "ridge" | "inset" | "outset") {
                    style = String::from("solid");
                }
            }
        }
    }

    if has_none_style {
        return None;
    }
    let w = width.unwrap_or(3); // outline-width 未指定時の UA 既定は "medium"(≈3px)
    let c = color?; // 色未指定なら描画しない（currentColor 相当の解決は簡易実装のため非対応）
    if w <= 0 {
        return None;
    }
    Some((c, w, style))
}

/// `object-fit` を解析。未指定/不明値は Fill（従来互換の全面引き伸ばし）。
pub(super) fn parse_object_fit(v: Option<&str>) -> super::ObjectFit {
    use super::ObjectFit;
    match v.map(|s| s.trim().to_ascii_lowercase()) {
        Some(ref s) if s == "contain" => ObjectFit::Contain,
        Some(ref s) if s == "cover" => ObjectFit::Cover,
        Some(ref s) if s == "none" => ObjectFit::None,
        Some(ref s) if s == "scale-down" => ObjectFit::ScaleDown,
        _ => ObjectFit::Fill,
    }
}

/// `object-position` を解析。background-position と同じキーワード/割合構文だが、
/// 未指定時の既定は (0.5, 0.5)（中央）で background-position の (0,0) とは異なる。
pub(super) fn parse_object_position(v: Option<&str>) -> (f32, f32) {
    match v {
        Some(_) => parse_bg_position(v),
        None => (0.5, 0.5),
    }
}

/// `transform-origin` を解析。background-position と同じキーワード/割合構文だが、
/// 未指定時の既定は (0.5, 0.5)（中央。CSS仕様どおり）。
pub(super) fn parse_transform_origin(v: Option<&str>) -> (f32, f32) {
    match v {
        Some(_) => parse_bg_position(v),
        None => (0.5, 0.5),
    }
}

pub(super) fn get_base_path(path: &str) -> String {
    if path == "/" {
        return String::from("/");
    }
    if let Some(last_slash_idx) = path.rfind('/') {
        if last_slash_idx == 0 {
            String::from("/")
        } else {
            String::from(path.get(..=last_slash_idx).unwrap_or("/"))
        }
    } else {
        String::from("/")
    }
}

pub(super) fn resolve_dom_paths(node: &mut crate::os_lib::dom::Node, base_path: &str) {
    if let crate::os_lib::dom::NodeType::Element {
        tag_name,
        attributes,
        ..
    } = &mut node.node_type
    {
        if tag_name == "picture" {
            // <picture> 直下の最初の <source srcset="..."> から img.src を解決する
            let mut source_url = None;
            for child in &node.children {
                if let crate::os_lib::dom::NodeType::Element { tag_name: c_tag, attributes: c_attrs, .. } = &child.node_type {
                    if c_tag == "source" {
                        if let Some(srcset) = c_attrs.get("srcset").or_else(|| c_attrs.get("src")) {
                            // srcset="url 1x, url 2x" などの簡易パース (最初のURLだけ取る)
                            let url = srcset.split_whitespace().next().unwrap_or(srcset);
                            source_url = Some(String::from(url));
                            break;
                        }
                    }
                }
            }
            if let Some(url) = source_url {
                for child in &mut node.children {
                    if let crate::os_lib::dom::NodeType::Element { tag_name: c_tag, attributes: c_attrs, .. } = &mut child.node_type {
                        if c_tag == "img" {
                            c_attrs.insert(String::from("src"), resolve_relative_path(base_path, &url));
                            break;
                        }
                    }
                }
            }
        } else if tag_name == "video" || tag_name == "audio" {
            // 直下の <source> 要素群から W3C Resource selection algorithm に基づき最適な src を解決する
            let parent_src = attributes.get("src").map(|s| s.as_str());
            let mut candidates = Vec::new();
            for child in &node.children {
                if let crate::os_lib::dom::NodeType::Element { tag_name: c_tag, attributes: c_attrs, .. } = &child.node_type {
                    if c_tag == "source" {
                        if let Some(src) = c_attrs.get("src") {
                            candidates.push(super::media_controls::MediaSourceCandidate {
                                src: src.clone(),
                                type_attr: c_attrs.get("type").cloned(),
                                media_attr: c_attrs.get("media").cloned(),
                            });
                        }
                    }
                }
            }
            if let Some(selected) = super::media_controls::select_media_source(
                tag_name,
                parent_src,
                &candidates,
                1024,
                768,
            ) {
                attributes.insert(String::from("src"), resolve_relative_path(base_path, &selected));
            }
            if tag_name == "video" {
                if let Some(src) = attributes.get_mut("src") {
                    *src = resolve_relative_path(base_path, src);
                }
                if let Some(video_src) = attributes.get_mut("video_src") {
                    *video_src = resolve_relative_path(base_path, video_src);
                }
            }
        } else if tag_name == "img" {
            if let Some(src) = attributes.get_mut("src") {
                *src = resolve_relative_path(base_path, src);
            }
        } else if tag_name == "a" || tag_name == "link" {
            if let Some(href) = attributes.get_mut("href") {
                *href = resolve_relative_path(base_path, href);
            }
        } else if tag_name == "script" {
            if let Some(src) = attributes.get_mut("src") {
                *src = resolve_relative_path(base_path, src);
            }
        }
    }
    for child in &mut node.children {
        resolve_dom_paths(child, base_path);
    }
}

///// CSS transform プロパティを (tx, ty, scale_x, scale_y, rotate_deg, skew_x, skew_y) にパース。
/// 幅・高さ・フォントサイズを受け取り、パーセンテージ（要素サイズ基準）や em、各種角度単位（deg, grad, rad, turn）を解決する。
pub(super) fn parse_transform_with_size(
    s: Option<&str>,
    elem_w: f32,
    elem_h: f32,
    font_px: f32,
) -> (i32, i32, f32, f32, f32, f32, f32) {
    super::css_units::parse_transform_with_size(s, elem_w, elem_h, font_px)
}

/// 後方互換性ラッパー（サイズ未指定時は 0 基準、16px フォントサイズで解決）。
pub(super) fn parse_transform(s: Option<&str>) -> (i32, i32, f32, f32, f32, f32, f32) {
    super::css_units::parse_transform_with_size(s, 0.0, 0.0, 16.0)
}


pub(super) fn parse_px_val(s: &str) -> i32 {
    if let Some(n) = s.strip_suffix("px") {
        n.trim().parse::<f32>().ok().map(|v| v as i32).unwrap_or(0)
    } else if let Some(n) = s.strip_suffix('%') {
        n.trim().parse::<f32>().ok().map(|v| v as i32).unwrap_or(0)
    } else {
        s.parse::<f32>().ok().map(|v| v as i32).unwrap_or(0)
    }
}

pub(super) fn extract_url_path(s: &str) -> Option<String> {
    let t = s.trim();
    if let Some(start_idx) = t.find("url(") {
        let after_url = t.get(start_idx + 4..).unwrap_or("");
        if let Some(end_idx) = after_url.find(')') {
            let path_raw = after_url.get(..end_idx).unwrap_or("");
            let path_clean = path_raw
                .trim_matches(|c| c == '\'' || c == '"' || c == '`')
                .trim();
            return Some(String::from(path_clean));
        }
    }
    None
}

/// `background-image: url(a.png), url(b.png)` のような複数レイヤーから
/// 全ての `url(...)` パスを出現順（CSS の重なり順どおり先頭が最前面）で抽出する。
pub(crate) fn extract_all_url_paths(s: &str) -> alloc::vec::Vec<alloc::string::String> {
    let mut out = alloc::vec::Vec::new();
    let mut rest = s;
    while let Some(start_idx) = rest.find("url(") {
        let after_url = rest.get(start_idx + 4..).unwrap_or("");
        let Some(end_idx) = after_url.find(')') else {
            break;
        };
        let path_raw = after_url.get(..end_idx).unwrap_or("");
        let path_clean = path_raw
            .trim_matches(|c| c == '\'' || c == '"' || c == '`')
            .trim();
        if !path_clean.is_empty() {
            out.push(alloc::string::String::from(path_clean));
        }
        rest = after_url.get(end_idx + 1..).unwrap_or("");
    }
    out
}