use crate::{
CssContainerRule, CssCounterStyleRule, CssDeclaration, CssFontFaceRule, CssImportRule,
CssKeyframeRule, CssKeyframesRule, CssLayerBlockRule, CssLayerStatementRule, CssMediaRule,
CssNamespaceRule, CssPageRule, CssPropertyRule, CssRule, CssScopeRule, CssStyleDeclaration,
CssStyleRule, CssStyleSheet, CssSupportsRule, OtherRule,
};
use muskitty_css::parser::{
parse_a_blocks_contents, AtRule, ComponentValue, Declaration, QualifiedRule, Rule, Stylesheet,
};
use muskitty_css::tokenizer::Token;
pub fn from_stylesheet(ss: &Stylesheet) -> CssStyleSheet {
from_stylesheet_with_origin(ss, crate::Origin::Author)
}
pub fn from_stylesheet_with_origin(ss: &Stylesheet, origin: crate::Origin) -> CssStyleSheet {
CssStyleSheet {
origin,
location: None,
media: Vec::new(),
title: String::new(),
alternate: false,
disabled: false,
css_rules: convert_rules(&ss.rules),
}
}
fn convert_rules(rules: &[Rule]) -> Vec<CssRule> {
rules
.iter()
.filter_map(|r| match r {
Rule::QualifiedRule(qr) => Some(CssRule::Style(convert_qualified_rule(qr))),
Rule::AtRule(ar) => Some(convert_at_rule(ar)),
Rule::Declarations(_) => None,
})
.collect()
}
fn convert_child_rules(rules: &[Rule], collect_decls: bool) -> (Vec<CssRule>, Vec<CssDeclaration>) {
let mut css_rules = Vec::new();
let mut extra_decls = Vec::new();
for r in rules {
match r {
Rule::QualifiedRule(qr) => css_rules.push(CssRule::Style(convert_qualified_rule(qr))),
Rule::AtRule(ar) => css_rules.push(convert_at_rule(ar)),
Rule::Declarations(decls) => {
if collect_decls {
for d in decls {
extra_decls.push(convert_declaration(d));
}
}
}
}
}
(css_rules, extra_decls)
}
fn convert_qualified_rule(qr: &QualifiedRule) -> CssStyleRule {
let mut style = CssStyleDeclaration::new();
for d in &qr.declarations {
style.push(convert_declaration(d));
}
let (css_rules, extra_decls) = convert_child_rules(&qr.child_rules, true);
for d in extra_decls {
style.push(d);
}
CssStyleRule {
selectors: qr.prelude.clone(),
style,
css_rules,
}
}
fn convert_at_rule(ar: &AtRule) -> CssRule {
match ar.name.to_ascii_lowercase().as_str() {
"import" => CssRule::Import(convert_import(ar)),
"media" => CssRule::Media(convert_media(ar)),
"font-face" => CssRule::FontFace(convert_font_face(ar)),
"page" => CssRule::Page(convert_page(ar)),
"keyframes" => CssRule::Keyframes(convert_keyframes(ar)),
"namespace" => CssRule::Namespace(convert_namespace(ar)),
"counter-style" => CssRule::CounterStyle(convert_counter_style(ar)),
"supports" => CssRule::Supports(convert_supports(ar)),
"layer" => convert_layer(ar),
"container" => CssRule::Container(convert_container(ar)),
"property" => CssRule::Property(convert_property(ar)),
"scope" => CssRule::Scope(convert_scope(ar)),
_ => CssRule::Other(convert_other(ar)),
}
}
fn convert_import(ar: &AtRule) -> CssImportRule {
let mut href = String::new();
let mut media = Vec::new();
let mut found_href = false;
for cv in &ar.prelude {
if !found_href {
if let Some(s) = extract_string_or_url(cv) {
href = s;
found_href = true;
continue;
}
if matches!(cv, ComponentValue::PreservedToken(Token::Whitespace)) {
continue;
}
continue;
}
media.push(cv.clone());
}
CssImportRule { href, media }
}
fn convert_media(ar: &AtRule) -> CssMediaRule {
let (css_rules, _) = convert_child_rules(ar.child_rules.as_deref().unwrap_or(&[]), false);
CssMediaRule {
condition: ar.prelude.clone(),
css_rules,
}
}
fn convert_namespace(ar: &AtRule) -> CssNamespaceRule {
let mut prefix = None;
let mut namespace_uri = String::new();
let mut seen_prefix = false;
for cv in &ar.prelude {
match cv {
ComponentValue::PreservedToken(Token::Whitespace) => continue,
ComponentValue::PreservedToken(Token::Ident(s)) if !seen_prefix => {
prefix = Some(s.clone());
seen_prefix = true;
}
_ => {
if let Some(s) = extract_string_or_url(cv) {
namespace_uri = s;
}
}
}
}
CssNamespaceRule {
namespace_uri,
prefix,
}
}
fn convert_supports(ar: &AtRule) -> CssSupportsRule {
let (css_rules, _) = convert_child_rules(ar.child_rules.as_deref().unwrap_or(&[]), false);
CssSupportsRule {
condition: ar.prelude.clone(),
css_rules,
}
}
fn convert_layer(ar: &AtRule) -> CssRule {
if let Some(child_rules) = &ar.child_rules {
let (css_rules, _) = convert_child_rules(child_rules, false);
let name = extract_dotted_layer_names(&ar.prelude).into_iter().next();
CssRule::LayerBlock(CssLayerBlockRule { name, css_rules })
} else {
let names = extract_dotted_layer_names(&ar.prelude);
CssRule::LayerStatement(CssLayerStatementRule { names })
}
}
fn convert_container(ar: &AtRule) -> CssContainerRule {
let (css_rules, _) = convert_child_rules(ar.child_rules.as_deref().unwrap_or(&[]), false);
CssContainerRule {
condition: ar.prelude.clone(),
css_rules,
}
}
fn convert_font_face(ar: &AtRule) -> CssFontFaceRule {
CssFontFaceRule {
style: convert_declaration_block(ar.declarations.as_deref()),
}
}
fn convert_page(ar: &AtRule) -> CssPageRule {
CssPageRule {
selectors: ar.prelude.clone(),
style: convert_declaration_block(ar.declarations.as_deref()),
}
}
fn convert_keyframes(ar: &AtRule) -> CssKeyframesRule {
let name = first_ident(&ar.prelude);
let mut keyframes = Vec::new();
if let Some(child_rules) = &ar.child_rules {
for r in child_rules {
if let Rule::QualifiedRule(qr) = r {
keyframes.push(CssKeyframeRule {
key_text: qr.prelude.clone(),
style: convert_declaration_block(Some(&qr.declarations)),
});
}
}
}
CssKeyframesRule { name, keyframes }
}
fn convert_counter_style(ar: &AtRule) -> CssCounterStyleRule {
CssCounterStyleRule {
name: first_ident(&ar.prelude).unwrap_or_default(),
style: convert_declaration_block(ar.declarations.as_deref()),
}
}
fn convert_property(ar: &AtRule) -> CssPropertyRule {
CssPropertyRule {
name: first_ident(&ar.prelude).unwrap_or_default(),
style: convert_declaration_block(ar.declarations.as_deref()),
}
}
fn convert_scope(ar: &AtRule) -> CssScopeRule {
let (css_rules, _) = convert_child_rules(ar.child_rules.as_deref().unwrap_or(&[]), false);
CssScopeRule {
prelude: ar.prelude.clone(),
css_rules,
}
}
fn convert_other(ar: &AtRule) -> OtherRule {
let (child_rules, extra_decls) =
convert_child_rules(ar.child_rules.as_deref().unwrap_or(&[]), true);
let mut declarations: Option<Vec<CssDeclaration>> = ar
.declarations
.as_ref()
.map(|decls| decls.iter().map(convert_declaration).collect());
if let Some(decls) = &mut declarations {
decls.extend(extra_decls);
}
OtherRule {
name: ar.name.clone(),
prelude: ar.prelude.clone(),
declarations,
child_rules,
}
}
pub fn parse_declaration_block(input: &str) -> CssStyleDeclaration {
let mut style = CssStyleDeclaration::new();
let contents = parse_a_blocks_contents(input);
for rule in &contents.rules {
if let Rule::Declarations(decls) = rule {
for d in decls {
style.push(convert_declaration(d));
}
}
}
style
}
fn convert_declaration(d: &Declaration) -> CssDeclaration {
CssDeclaration {
name: d.name.clone(),
value: d.value.clone(),
important: d.important,
original_text: d.original_text.clone(),
}
}
fn convert_declaration_block(decls: Option<&[Declaration]>) -> CssStyleDeclaration {
let mut style = CssStyleDeclaration::new();
if let Some(decls) = decls {
for d in decls {
style.push(convert_declaration(d));
}
}
style
}
fn first_ident(prelude: &[ComponentValue]) -> Option<String> {
prelude.iter().find_map(|cv| match cv {
ComponentValue::PreservedToken(Token::Ident(s)) => Some(s.clone()),
_ => None,
})
}
fn extract_string_or_url(cv: &ComponentValue) -> Option<String> {
match cv {
ComponentValue::PreservedToken(Token::String(s)) => Some(s.clone()),
ComponentValue::PreservedToken(Token::Url(s)) => Some(s.clone()),
ComponentValue::Function(f) if f.name.eq_ignore_ascii_case("url") => {
if let [ComponentValue::PreservedToken(Token::String(s))] = f.value.as_slice() {
Some(s.clone())
} else {
None
}
}
_ => None,
}
}
fn extract_dotted_layer_names(prelude: &[ComponentValue]) -> Vec<String> {
let mut names = Vec::new();
let mut current = String::new();
for cv in prelude {
match cv {
ComponentValue::PreservedToken(Token::Whitespace) => {}
ComponentValue::PreservedToken(Token::Comma) => {
names.push(std::mem::take(&mut current));
}
ComponentValue::PreservedToken(Token::Ident(s)) => current.push_str(s),
ComponentValue::PreservedToken(Token::Delim('.')) => current.push('.'),
_ => {}
}
}
if !current.is_empty() {
names.push(current);
}
names
}