yass-css 0.2.0

data/ext/yass/src/declarations/animation/timing_function/cubic_bezier.rs

@@ -0,0 +1,60 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::specified::Number;
+
+use crate::{cached_value::CachedValue, declarations::number::YNumber};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Animation::TimingFunction::CubicBezier", mark)]
+pub struct YCubicBezier {
+    x1: CachedValue<Number>,
+    y1: CachedValue<Number>,
+    x2: CachedValue<Number>,
+    y2: CachedValue<Number>
+}
+
+impl YCubicBezier {
+    pub fn new(x1: Number, y1: Number, x2: Number, y2: Number) -> Self {
+        Self {
+            x1: CachedValue::new(x1.clone(), |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            y1: CachedValue::new(y1.clone(), |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            x2: CachedValue::new(x2.clone(), |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+
+            y2: CachedValue::new(y2.clone(), |number, ruby| {
+                YNumber::new(number.get()).into_value_with(ruby)
+            }),
+        }
+    }
+
+    pub fn x1(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.x1.get(ruby)
+    }
+
+    pub fn y1(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.y1.get(ruby)
+    }
+
+    pub fn x2(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.x2.get(ruby)
+    }
+
+    pub fn y2(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.y2.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YCubicBezier {
+    fn mark(&self, marker: &gc::Marker) {
+        self.x1.mark(marker);
+        self.y1.mark(marker);
+        self.x2.mark(marker);
+        self.y2.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation/timing_function/init.rs

@@ -0,0 +1,29 @@
+use magnus::{Error, Module, RModule, Ruby, method};
+
+use crate::declarations::animation::timing_function::{cubic_bezier::YCubicBezier, keyword::YKeyword, piecewise_linear_function::{YPiecewiseLinearFunction, YPiecewiseLinearFunctionEntry}, steps::YSteps};
+
+pub fn init(ruby: &Ruby, _yass_module: &RModule, _declarations_module: &RModule, animation_module: &RModule) -> Result<(), Error> {
+    let timing_function_module = animation_module.define_module("TimingFunction")?;
+
+    let cubic_bezier_class = timing_function_module.define_class("CubicBezier", ruby.class_object())?;
+    cubic_bezier_class.define_method("x1", method!(YCubicBezier::x1, 0))?;
+    cubic_bezier_class.define_method("y1", method!(YCubicBezier::y1, 0))?;
+    cubic_bezier_class.define_method("x2", method!(YCubicBezier::x2, 0))?;
+    cubic_bezier_class.define_method("y2", method!(YCubicBezier::y2, 0))?;
+
+    let keyword_class = timing_function_module.define_class("Keyword", ruby.class_object())?;
+    keyword_class.define_method("value", method!(YKeyword::value, 0))?;
+
+    let piecewise_linear_function_class = timing_function_module.define_class("PiecewiseLinearFunction", ruby.class_object())?;
+    piecewise_linear_function_class.define_method("values", method!(YPiecewiseLinearFunction::values, 0))?;
+
+    let piecewise_linear_function_entry_class = timing_function_module.define_class("PiecewiseLinearFunctionEntry", ruby.class_object())?;
+    piecewise_linear_function_entry_class.define_method("x", method!(YPiecewiseLinearFunctionEntry::x, 0))?;
+    piecewise_linear_function_entry_class.define_method("y", method!(YPiecewiseLinearFunctionEntry::y, 0))?;
+
+    let steps_class = timing_function_module.define_class("Steps", ruby.class_object())?;
+    steps_class.define_method("count", method!(YSteps::count, 0))?;
+    steps_class.define_method("position", method!(YSteps::position, 0))?;
+
+    Ok(())
+}

data/ext/yass/src/declarations/animation/timing_function/keyword.rs

@@ -0,0 +1,23 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::generics::easing::TimingKeyword;
+
+#[magnus::wrap(class = "Yass::Declarations::Animation::TimingFunction::Keyword")]
+pub struct YKeyword {
+    keyword: TimingKeyword
+}
+
+impl YKeyword {
+    pub fn new(keyword: TimingKeyword) -> Self {
+        Self { keyword }
+    }
+
+    pub fn value(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.keyword {
+            TimingKeyword::Linear => ruby.intern("linear"),
+            TimingKeyword::Ease => ruby.intern("ease"),
+            TimingKeyword::EaseIn => ruby.intern("ease_in"),
+            TimingKeyword::EaseOut => ruby.intern("ease_out"),
+            TimingKeyword::EaseInOut => ruby.intern("ease_in_out"),
+        }
+    }
+}

data/ext/yass/src/declarations/animation/timing_function/mod.rs

@@ -0,0 +1,5 @@
+pub mod cubic_bezier;
+pub mod init;
+pub mod keyword;
+pub mod piecewise_linear_function;
+pub mod steps;

data/ext/yass/src/declarations/animation/timing_function/piecewise_linear_function.rs

@@ -0,0 +1,49 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::piecewise_linear::{PiecewiseLinearFunction, PiecewiseLinearFunctionEntry};
+
+use crate::cached_value_list::CachedValueList;
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Animation::TimingFunction::PiecewiseLinearFunction", mark)]
+pub struct YPiecewiseLinearFunction {
+    values: CachedValueList<PiecewiseLinearFunctionEntry>
+}
+
+impl YPiecewiseLinearFunction {
+    pub fn new(linear_function: PiecewiseLinearFunction) -> Self {
+        Self {
+            values: CachedValueList::new(linear_function.iter().map(|value| value.clone()).collect(), |value, _ctx, ruby| {
+                YPiecewiseLinearFunctionEntry::new(*value).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YPiecewiseLinearFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[magnus::wrap(class = "Yass::Declarations::Animation::TimingFunction::PiecewiseLinearFunctionEntry")]
+pub struct YPiecewiseLinearFunctionEntry {
+    entry: PiecewiseLinearFunctionEntry
+}
+
+impl YPiecewiseLinearFunctionEntry {
+    pub fn new(entry: PiecewiseLinearFunctionEntry) -> Self {
+        Self { entry }
+    }
+
+    pub fn x(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.entry.x
+    }
+
+    pub fn y(_ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> f32 {
+        rb_self.entry.y
+    }
+}

data/ext/yass/src/declarations/animation/timing_function/steps.rs

@@ -0,0 +1,30 @@
+use magnus::{Ruby, typed_data, value::Id};
+use style::values::generics::easing::StepPosition;
+
+#[magnus::wrap(class = "Yass::Declarations::Animation::TimingFunction::Steps")]
+pub struct YSteps {
+    count: i32,
+    position: StepPosition
+}
+
+impl YSteps {
+    pub fn new(count: i32, position: StepPosition) -> Self {
+        Self { count, position }
+    }
+
+    pub fn count(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> i32 {
+        let _ = ruby;
+        rb_self.count
+    }
+
+    pub fn position(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Id {
+        match rb_self.position {
+            StepPosition::JumpStart => ruby.intern("jump_start"),
+            StepPosition::JumpEnd => ruby.intern("jump_end"),
+            StepPosition::JumpNone => ruby.intern("jump_none"),
+            StepPosition::JumpBoth => ruby.intern("jump_both"),
+            StepPosition::Start => ruby.intern("start"),
+            StepPosition::End => ruby.intern("end"),
+        }
+    }
+}

data/ext/yass/src/declarations/animation/view_function.rs

@@ -0,0 +1,40 @@
+use magnus::{DataTypeFunctions, IntoValue, Ruby, TypedData, Value, gc, typed_data};
+use style::values::{computed::ScrollAxis, generics::animation::{ViewFunction, ViewTimelineInset}, specified::LengthPercentage};
+
+use crate::{cached_value::CachedValue, declarations::animation::{inset::YInset, scroll_axis::YScrollAxis}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::Animation::ViewFunction", mark)]
+pub struct YViewFunction {
+    scroll_axis: CachedValue<ScrollAxis>,
+    inset: CachedValue<ViewTimelineInset<LengthPercentage>>
+}
+
+impl YViewFunction {
+    pub fn new(view_function: ViewFunction<LengthPercentage>) -> Self {
+        Self {
+            scroll_axis: CachedValue::new(view_function.axis, |axis, ruby| {
+                YScrollAxis::new(*axis).into_value_with(ruby)
+            }),
+
+            inset: CachedValue::new(view_function.inset, |inset, ruby| {
+                YInset::new(inset.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn scroll_axis(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.scroll_axis.get(ruby)
+    }
+
+    pub fn inset(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Value {
+        rb_self.inset.get(ruby)
+    }
+}
+
+impl DataTypeFunctions for YViewFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.scroll_axis.mark(marker);
+        self.inset.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation_composition.rs

@@ -0,0 +1,29 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::{properties::longhands::animation_composition::SpecifiedValue, values::computed::AnimationComposition};
+
+#[magnus::wrap(class = "Yass::Declarations::AnimationComposition")]
+pub struct YAnimationComposition {
+    specified_value: SpecifiedValue
+}
+
+impl YAnimationComposition {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for value in rb_self.specified_value.0.as_ref() {
+            let id = match value {
+                AnimationComposition::Replace => ruby.intern("replace"),
+                AnimationComposition::Add => ruby.intern("add"),
+                AnimationComposition::Accumulate => ruby.intern("accumulate"),
+            };
+
+            result.push(id)?;
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/declarations/animation_delay.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::animation_delay::SpecifiedValue, values::specified::Time};
+
+use crate::{declarations::time::YTime, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationDelay", mark)]
+pub struct YAnimationDelay {
+    times: CachedValueList<Time>
+}
+
+impl YAnimationDelay {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            times: CachedValueList::new(specified_value.0.to_vec(), |time, _ctx, ruby| {
+                YTime::new(time.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.times.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnimationDelay {
+    fn mark(&self, marker: &gc::Marker) {
+        self.times.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation_direction.rs

@@ -0,0 +1,30 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::{properties::longhands::animation_direction::SpecifiedValue, values::computed::AnimationDirection};
+
+#[magnus::wrap(class = "Yass::Declarations::AnimationDirection")]
+pub struct YAnimationDirection {
+    specified_value: SpecifiedValue
+}
+
+impl YAnimationDirection {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for direction in rb_self.specified_value.0.as_ref() {
+            let id = match direction {
+            AnimationDirection::Normal => ruby.intern("normal"),
+            AnimationDirection::Reverse => ruby.intern("reverse"),
+            AnimationDirection::Alternate => ruby.intern("alternate"),
+            AnimationDirection::AlternateReverse => ruby.intern("alternate_reverse"),
+            };
+
+            result.push(id)?;
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/declarations/animation_duration.rs

@@ -0,0 +1,67 @@
+use std::cell::RefCell;
+
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, Value, gc, typed_data, value::{Opaque, ReprValue}};
+use style::{properties::longhands::animation_duration::SpecifiedValue, values::{generics::animation::AnimationDuration, specified::Time}};
+
+use crate::{declarations::time::YTime, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationDuration", mark)]
+pub struct YAnimationDuration {
+    values: CachedValueList<AnimationDuration<Time>>
+}
+
+impl YAnimationDuration {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                YAnimationDurationValue::new(value.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnimationDuration {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationDurationValue", mark)]
+pub struct YAnimationDurationValue {
+    animation_duration: AnimationDuration<Time>,
+    time: RefCell<Option<Opaque<typed_data::Obj<YTime>>>>
+}
+
+impl YAnimationDurationValue {
+    pub fn new(animation_duration: AnimationDuration<Time>) -> Self {
+        Self { animation_duration, time: RefCell::new(None) }
+    }
+
+    pub fn time(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Option<Value> {
+        match rb_self.animation_duration {
+            AnimationDuration::Time(time) => {
+                if rb_self.time.borrow().is_none() {
+                    *rb_self.time.borrow_mut() = Some(Opaque::from(ruby.obj_wrap(YTime::new(time))));
+                }
+
+                Some(ruby.get_inner(rb_self.time.borrow().unwrap()).as_value())
+            }
+
+            AnimationDuration::Auto => None
+        }
+    }
+}
+
+impl DataTypeFunctions for YAnimationDurationValue {
+    fn mark(&self, marker: &gc::Marker) {
+        if let Some(time) = self.time.borrow().as_ref() {
+            marker.mark(*time);
+        }
+    }
+}

data/ext/yass/src/declarations/animation_fill_mode.rs

@@ -0,0 +1,30 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::{properties::longhands::animation_fill_mode::SpecifiedValue, values::computed::AnimationFillMode};
+
+#[magnus::wrap(class = "Yass::Declarations::AnimationFillMode")]
+pub struct YAnimationFillMode {
+    specified_value: SpecifiedValue
+}
+
+impl YAnimationFillMode {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for fill_mode in rb_self.specified_value.0.as_ref() {
+            let id = match fill_mode {
+                AnimationFillMode::None => ruby.intern("none"),
+                AnimationFillMode::Forwards => ruby.intern("forwards"),
+                AnimationFillMode::Backwards => ruby.intern("backwards"),
+                AnimationFillMode::Both => ruby.intern("both"),
+            };
+
+            result.push(id)?
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/declarations/animation_iteration_count.rs

@@ -0,0 +1,33 @@
+use magnus::{Error, Module, RArray, Ruby, typed_data};
+use style::{properties::longhands::animation_iteration_count::SpecifiedValue, values::specified::AnimationIterationCount};
+
+#[magnus::wrap(class = "Yass::Declarations::AnimationIterationCount")]
+pub struct YAnimationIterationCount {
+    specified_value: SpecifiedValue
+}
+
+impl YAnimationIterationCount {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for count in rb_self.specified_value.0.as_ref() {
+            let float = match count {
+                AnimationIterationCount::Number(num) => {
+                    ruby.float_from_f64(num.0.get() as f64)
+                },
+
+                AnimationIterationCount::Infinite => {
+                    ruby.class_float().const_get("INFINITY")?
+                }
+            };
+
+            result.push(float)?;
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/declarations/animation_name.rs

@@ -0,0 +1,23 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::properties::longhands::animation_name::SpecifiedValue;
+
+#[magnus::wrap(class = "Yass::Declarations::AnimationName")]
+pub struct YAnimationName {
+    specified_value: SpecifiedValue
+}
+
+impl YAnimationName {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for name in rb_self.specified_value.0.as_ref() {
+            result.push(ruby.str_from_slice(name.0.as_atom().as_bytes()))?;
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/declarations/animation_play_state.rs

@@ -0,0 +1,28 @@
+use magnus::{Error, RArray, Ruby, typed_data};
+use style::{properties::longhands::animation_play_state::SpecifiedValue, values::computed::AnimationPlayState};
+
+#[magnus::wrap(class = "Yass::Declarations::AnimationPlayState")]
+pub struct YAnimationPlayState {
+    specified_value: SpecifiedValue
+}
+
+impl YAnimationPlayState {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self { specified_value }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        let result = ruby.ary_new_capa(rb_self.specified_value.0.len());
+
+        for play_state in rb_self.specified_value.0.as_ref() {
+            let id = match play_state {
+                AnimationPlayState::Running => ruby.intern("running"),
+                AnimationPlayState::Paused => ruby.intern("paused"),
+            };
+
+            result.push(id)?;
+        }
+
+        Ok(result)
+    }
+}

data/ext/yass/src/declarations/animation_range_end.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::animation_range_end::SpecifiedValue, values::{generics::{animation::AnimationRangeEnd}, specified::{LengthPercentage}}};
+
+use crate::{declarations::animation::range_value::YRangeValue, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationRangeEnd", mark)]
+pub struct YAnimationRangeEnd {
+    values: CachedValueList<AnimationRangeEnd<LengthPercentage>>
+}
+
+impl YAnimationRangeEnd {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                YRangeValue::new(value.0.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnimationRangeEnd {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation_range_start.rs

@@ -0,0 +1,30 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::animation_range_start::SpecifiedValue, values::specified::{AnimationRangeStart}};
+
+use crate::{declarations::animation::range_value::YRangeValue, cached_value_list::CachedValueList};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationRangeStart", mark)]
+pub struct YAnimationRangeStart {
+    values: CachedValueList<AnimationRangeStart>
+}
+
+impl YAnimationRangeStart {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                YRangeValue::new(value.0.clone()).into_value_with(ruby)
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnimationRangeStart {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation_timeline.rs

@@ -0,0 +1,42 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{properties::longhands::animation_timeline::SpecifiedValue, values::{generics::{animation::AnimationTimeline}, specified::LengthPercentage}};
+use style_traits::ToCss;
+
+use crate::{cached_value_list::CachedValueList, declarations::{animation::{auto::YAuto, scroll_function::YScrollFunction, timeline_name::YTimelineName, view_function::YViewFunction}}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationTimeline", mark)]
+pub struct YAnimationTimeline {
+    values: CachedValueList<AnimationTimeline<LengthPercentage>>
+}
+
+impl YAnimationTimeline {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                match value {
+                    AnimationTimeline::Auto => YAuto::new().into_value_with(ruby),
+                    AnimationTimeline::Scroll(scroll_fn) => {
+                        YScrollFunction::new(scroll_fn.clone()).into_value_with(ruby)
+                    },
+                    AnimationTimeline::Timeline(timeline_name) => {
+                        YTimelineName::new(timeline_name.to_css_string()).into_value_with(ruby)
+                    },
+                    AnimationTimeline::View(generic_view_function) => {
+                        YViewFunction::new(generic_view_function.clone()).into_value_with(ruby)
+                    },
+                }
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnimationTimeline {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}

data/ext/yass/src/declarations/animation_timing_function.rs

@@ -0,0 +1,46 @@
+use magnus::{DataTypeFunctions, Error, IntoValue, RArray, Ruby, TypedData, gc, typed_data};
+use style::{piecewise_linear::PiecewiseLinearFunction, properties::longhands::animation_timing_function::SpecifiedValue, values::{generics::easing::TimingFunction, specified::{Integer, Number}}};
+
+use crate::{cached_value_list::CachedValueList, declarations::{animation::timing_function::{cubic_bezier::YCubicBezier, keyword::YKeyword, piecewise_linear_function::YPiecewiseLinearFunction, steps::YSteps}}};
+
+#[derive(TypedData)]
+#[magnus(class = "Yass::Declarations::AnimationTimingFunction", mark)]
+pub struct YAnimationTimingFunction {
+    values: CachedValueList<TimingFunction<Integer, Number, PiecewiseLinearFunction>>
+}
+
+impl YAnimationTimingFunction {
+    pub fn new(specified_value: SpecifiedValue) -> Self {
+        Self {
+            values: CachedValueList::new(specified_value.0.to_vec(), |value, _ctx, ruby| {
+                match value {
+                    TimingFunction::Keyword(timing_keyword) => {
+                        YKeyword::new(timing_keyword.clone()).into_value_with(ruby)
+                    },
+
+                    TimingFunction::CubicBezier { x1, y1, x2, y2 } => {
+                        YCubicBezier::new(x1.clone(), y1.clone(), x2.clone(), y2.clone()).into_value_with(ruby)
+                    },
+
+                    TimingFunction::Steps(steps, step_position) => {
+                        YSteps::new(steps.value(), *step_position).into_value_with(ruby)
+                    },
+
+                    TimingFunction::LinearFunction(linear_function) => {
+                        YPiecewiseLinearFunction::new(linear_function.clone()).into_value_with(ruby)
+                    },
+                }
+            })
+        }
+    }
+
+    pub fn values(ruby: &Ruby, rb_self: typed_data::Obj<Self>) -> Result<RArray, Error> {
+        rb_self.values.to_a(ruby)
+    }
+}
+
+impl DataTypeFunctions for YAnimationTimingFunction {
+    fn mark(&self, marker: &gc::Marker) {
+        self.values.mark(marker);
+    }
+}