mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
380 lines
12 KiB
Rust
380 lines
12 KiB
Rust
use crate::interfaces as web_api_interfaces;
|
|
use cssparser::{Parser, Token};
|
|
use moli_v8_util::{get_private_value, set_private_value, throw_type_error, v8_string};
|
|
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
|
|
use moli_webidl as webidl;
|
|
|
|
const CSS_STYLE_VALUE_TEXT_SLOT: &str = "__moliCssStyleValueText";
|
|
const CSS_KEYWORD_VALUE_VALUE_SLOT: &str = "__moliCssKeywordValueValue";
|
|
const CSS_UNIT_VALUE_VALUE_SLOT: &str = "__moliCssUnitValueValue";
|
|
const CSS_UNIT_VALUE_UNIT_SLOT: &str = "__moliCssUnitValueUnit";
|
|
|
|
const VALID_UNIT_NAMES: &[&str] = &[
|
|
"number", "percent", "em", "ex", "ch", "ic", "rem", "lh", "rlh", "vw", "vh", "vi", "vb",
|
|
"vmin", "vmax", "cm", "mm", "q", "in", "pt", "pc", "px", "deg", "grad", "rad", "turn", "s",
|
|
"ms", "hz", "khz", "dpi", "dpcm", "dppx", "fr",
|
|
];
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(interface = web_api_interfaces::CSSStyleValue)]
|
|
struct CssStyleValueObjectDeclaration {
|
|
#[webapi(slot = CSS_STYLE_VALUE_TEXT_SLOT)]
|
|
text: String,
|
|
}
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(interface = web_api_interfaces::CSSKeywordValue)]
|
|
struct CssKeywordValueObjectDeclaration {
|
|
#[webapi(slot = CSS_KEYWORD_VALUE_VALUE_SLOT)]
|
|
value: String,
|
|
}
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(interface = web_api_interfaces::CSSUnitValue)]
|
|
struct CssUnitValueObjectDeclaration {
|
|
#[webapi(slot = CSS_UNIT_VALUE_VALUE_SLOT)]
|
|
value: f64,
|
|
#[webapi(slot = CSS_UNIT_VALUE_UNIT_SLOT)]
|
|
unit: String,
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::CSSKeywordValue, enumerable)]
|
|
struct CssKeywordValuePrototypeDeclaration {
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = css_keyword_value_value_getter_callback,
|
|
setter = css_keyword_value_value_setter_callback
|
|
)]
|
|
value: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::CSSStyleValue, enumerable, receiver)]
|
|
struct CssStyleValuePrototypeDeclaration {
|
|
#[webapi(method = "toString", callback = css_style_value_to_string_callback, length = 0)]
|
|
to_string: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::CSSUnitValue, enumerable)]
|
|
struct CssUnitValuePrototypeDeclaration {
|
|
#[webapi(
|
|
accessor_property,
|
|
getter = css_unit_value_value_getter_callback,
|
|
setter = css_unit_value_value_setter_callback
|
|
)]
|
|
value: (),
|
|
#[webapi(accessor_property, getter = css_unit_value_unit_getter_callback)]
|
|
unit: (),
|
|
}
|
|
|
|
#[derive(webidl::WebIdlArgs)]
|
|
#[webidl(prefix = "CSSUnitValue")]
|
|
struct CssUnitValueConstructorArgs {
|
|
#[webidl(required)]
|
|
value: f64,
|
|
#[webidl(required)]
|
|
unit: String,
|
|
}
|
|
|
|
#[derive(webidl::WebIdlArgs)]
|
|
#[webidl(prefix = "CSSKeywordValue")]
|
|
struct CssKeywordValueConstructorArgs {
|
|
#[webidl(required)]
|
|
keyword: String,
|
|
}
|
|
|
|
pub fn install_typed_value_template_bindings<'s>(
|
|
scope: &mut v8::PinScope<'s, '_, ()>,
|
|
template: v8::Local<'s, v8::FunctionTemplate>,
|
|
interface_name: &str,
|
|
) {
|
|
let prototype = template.prototype_template(scope);
|
|
match interface_name {
|
|
"CSSStyleValue" => {
|
|
CssStyleValuePrototypeDeclaration::initialize_prototype_template(scope, prototype);
|
|
}
|
|
"CSSKeywordValue" => {
|
|
CssKeywordValuePrototypeDeclaration::initialize_prototype_template(scope, prototype);
|
|
}
|
|
"CSSUnitValue" => {
|
|
CssUnitValuePrototypeDeclaration::initialize_prototype_template(scope, prototype);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
pub fn css_keyword_value_constructor_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
if !args.is_construct_call() {
|
|
throw_type_error(
|
|
scope,
|
|
"Failed to construct 'CSSKeywordValue': Please use the 'new' operator.",
|
|
);
|
|
return;
|
|
}
|
|
let Some(parsed) = webidl::parse_args::<CssKeywordValueConstructorArgs>(scope, &args) else {
|
|
return;
|
|
};
|
|
if parsed.keyword.is_empty() {
|
|
throw_type_error(scope, "CSSKeywordValue does not support empty strings");
|
|
return;
|
|
}
|
|
CssKeywordValueObjectDeclaration::new(parsed.keyword)
|
|
.initialize(scope, args.this())
|
|
.expect("CSSKeywordValue declaration should initialize");
|
|
rv.set(args.this().into());
|
|
}
|
|
|
|
pub fn css_unit_value_constructor_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
if !args.is_construct_call() {
|
|
throw_type_error(
|
|
scope,
|
|
"Failed to construct 'CSSUnitValue': Please use the 'new' operator.",
|
|
);
|
|
return;
|
|
}
|
|
let Some(parsed) = webidl::parse_args::<CssUnitValueConstructorArgs>(scope, &args) else {
|
|
return;
|
|
};
|
|
let Some(unit) = normalize_unit_name(&parsed.unit) else {
|
|
throw_type_error(scope, &format!("Invalid unit: {}", parsed.unit));
|
|
return;
|
|
};
|
|
CssUnitValueObjectDeclaration::new(parsed.value, unit)
|
|
.initialize(scope, args.this())
|
|
.expect("CSSUnitValue declaration should initialize");
|
|
rv.set(args.this().into());
|
|
}
|
|
|
|
pub fn style_value_from_text<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
text: &str,
|
|
allow_keyword: bool,
|
|
) -> v8::Local<'s, v8::Object> {
|
|
if let Some((value, unit)) = parse_single_unit_value(text) {
|
|
return CssUnitValueObjectDeclaration::new(value, unit)
|
|
.bind(scope)
|
|
.expect("CSSUnitValue declaration should bind");
|
|
}
|
|
if allow_keyword && let Some(keyword) = parse_single_keyword_value(text) {
|
|
return CssKeywordValueObjectDeclaration::new(keyword)
|
|
.bind(scope)
|
|
.expect("CSSKeywordValue declaration should bind");
|
|
}
|
|
CssStyleValueObjectDeclaration::new(text.to_owned())
|
|
.bind(scope)
|
|
.expect("CSSStyleValue declaration should bind")
|
|
}
|
|
|
|
fn parse_single_keyword_value(text: &str) -> Option<String> {
|
|
let input = text;
|
|
let mut parser = Parser::new(input);
|
|
parser
|
|
.parse_entirely(|input| match input.next()?.clone() {
|
|
Token::Ident(keyword) => Ok(keyword.to_string()),
|
|
_ => Err(cssparser::ParseError::<()>::custom(())),
|
|
})
|
|
.ok()
|
|
}
|
|
|
|
fn parse_single_unit_value(text: &str) -> Option<(f64, String)> {
|
|
let input = text;
|
|
let mut parser = Parser::new(input);
|
|
parser
|
|
.parse_entirely(|input| {
|
|
let token = input.next()?.clone();
|
|
match token {
|
|
Token::Number { value, .. } => Ok((f64::from(value), "number".to_owned())),
|
|
Token::Percentage { unit_value, .. } => {
|
|
Ok((f64::from(unit_value) * 100.0, "percent".to_owned()))
|
|
}
|
|
Token::Dimension { value, unit, .. } => {
|
|
let unit = unit.to_ascii_lowercase();
|
|
if normalize_unit_name(&unit).is_none() {
|
|
return Err(cssparser::ParseError::<()>::custom(()));
|
|
}
|
|
Ok((f64::from(value), unit))
|
|
}
|
|
_ => Err(cssparser::ParseError::<()>::custom(())),
|
|
}
|
|
})
|
|
.ok()
|
|
}
|
|
|
|
fn normalize_unit_name(unit: &str) -> Option<String> {
|
|
let unit = unit.to_ascii_lowercase();
|
|
VALID_UNIT_NAMES.contains(&unit.as_str()).then_some(unit)
|
|
}
|
|
|
|
fn css_style_value_to_string_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
if let Some(unit) = css_unit_value_unit(scope, args.this()) {
|
|
let value = css_unit_value_number(scope, args.this()).unwrap_or(0.0);
|
|
let number = v8::Number::new(scope, value)
|
|
.to_string(scope)
|
|
.map(|value| value.to_rust_string_lossy(scope))
|
|
.unwrap_or_else(|| value.to_string());
|
|
let text = match unit.as_str() {
|
|
"number" => number,
|
|
"percent" => format!("{number}%"),
|
|
_ => format!("{number}{unit}"),
|
|
};
|
|
if let Some(text) = v8_string(scope, &text) {
|
|
rv.set(text.into());
|
|
}
|
|
return;
|
|
}
|
|
if let Some(keyword) = css_keyword_value(scope, args.this()) {
|
|
if let Some(keyword) = v8_string(scope, &keyword) {
|
|
rv.set(keyword.into());
|
|
}
|
|
return;
|
|
}
|
|
let text = get_private_value(scope, args.this(), CSS_STYLE_VALUE_TEXT_SLOT)
|
|
.and_then(|value| value.to_string(scope))
|
|
.unwrap_or_else(|| v8::String::empty(scope));
|
|
rv.set(text.into());
|
|
}
|
|
|
|
fn css_keyword_value_value_getter_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
let Some(keyword) = css_keyword_value(scope, args.this()) else {
|
|
throw_type_error(scope, "Illegal invocation");
|
|
return;
|
|
};
|
|
if let Some(keyword) = v8_string(scope, &keyword) {
|
|
rv.set(keyword.into());
|
|
}
|
|
}
|
|
|
|
fn css_keyword_value_value_setter_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
if css_keyword_value(scope, args.this()).is_none() {
|
|
throw_type_error(scope, "Illegal invocation");
|
|
return;
|
|
}
|
|
let keyword = match webidl::convert::<webidl::DomString>(
|
|
scope,
|
|
args.get(0),
|
|
webidl::Context::member("CSSKeywordValue", "value"),
|
|
) {
|
|
Ok(keyword) => keyword.0,
|
|
Err(error) => {
|
|
webidl::throw_error(scope, &error);
|
|
return;
|
|
}
|
|
};
|
|
if keyword.is_empty() {
|
|
throw_type_error(scope, "CSSKeywordValue does not support empty strings");
|
|
return;
|
|
}
|
|
if let Some(keyword) = v8_string(scope, &keyword) {
|
|
set_private_value(
|
|
scope,
|
|
args.this(),
|
|
CSS_KEYWORD_VALUE_VALUE_SLOT,
|
|
keyword.into(),
|
|
);
|
|
}
|
|
rv.set_undefined();
|
|
}
|
|
|
|
fn css_unit_value_value_getter_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
let Some(value) = css_unit_value_number(scope, args.this()) else {
|
|
throw_type_error(scope, "Illegal invocation");
|
|
return;
|
|
};
|
|
rv.set(v8::Number::new(scope, value).into());
|
|
}
|
|
|
|
fn css_unit_value_value_setter_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
if css_unit_value_unit(scope, args.this()).is_none() {
|
|
throw_type_error(scope, "Illegal invocation");
|
|
return;
|
|
}
|
|
let value = match webidl::convert::<webidl::Double>(
|
|
scope,
|
|
args.get(0),
|
|
webidl::Context::member("CSSUnitValue", "value"),
|
|
) {
|
|
Ok(value) => f64::from(value),
|
|
Err(error) => {
|
|
webidl::throw_error(scope, &error);
|
|
return;
|
|
}
|
|
};
|
|
set_private_value(
|
|
scope,
|
|
args.this(),
|
|
CSS_UNIT_VALUE_VALUE_SLOT,
|
|
v8::Number::new(scope, value).into(),
|
|
);
|
|
rv.set_undefined();
|
|
}
|
|
|
|
fn css_unit_value_unit_getter_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
let Some(unit) = css_unit_value_unit(scope, args.this()) else {
|
|
throw_type_error(scope, "Illegal invocation");
|
|
return;
|
|
};
|
|
if let Some(unit) = v8_string(scope, &unit) {
|
|
rv.set(unit.into());
|
|
}
|
|
}
|
|
|
|
fn css_unit_value_number<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
receiver: v8::Local<'s, v8::Object>,
|
|
) -> Option<f64> {
|
|
get_private_value(scope, receiver, CSS_UNIT_VALUE_VALUE_SLOT)
|
|
.and_then(|value| value.number_value(scope))
|
|
}
|
|
|
|
fn css_keyword_value<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
receiver: v8::Local<'s, v8::Object>,
|
|
) -> Option<String> {
|
|
get_private_value(scope, receiver, CSS_KEYWORD_VALUE_VALUE_SLOT)
|
|
.and_then(|value| value.to_string(scope))
|
|
.map(|value| value.to_rust_string_lossy(scope))
|
|
}
|
|
|
|
fn css_unit_value_unit<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
receiver: v8::Local<'s, v8::Object>,
|
|
) -> Option<String> {
|
|
get_private_value(scope, receiver, CSS_UNIT_VALUE_UNIT_SLOT)
|
|
.and_then(|value| value.to_string(scope))
|
|
.map(|value| value.to_rust_string_lossy(scope))
|
|
}
|