Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / interpolation_2.lucb

#==============================================================================================
#
#   interpolation_2 - CSS interpolation: grid track lists and interpolate_property
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/CSS/Interpolation.cpp (lines 533-833), by region p4a:
#       expanding a grid track list into tracks and line names and interpolating two of them,
#       interpolate_property (keywords resolved, then by the property's animation type: by
#       computed value, repeatable list, or the custom rules of transform, shadows, font-style,
#       font-variation-settings, visibility, content-visibility, display, scale, translate,
#       rotate, filters, grid templates and stroke-dasharray, else discrete), and whether two
#       values of a property are transitionable.
#
#       Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       Copyright (c) 2024, Matthew Olsson <mattco@serenityos.org>
#       Copyright (c) 2025-2026, Tim Ledbetter <tim.ledbetter@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Grid track lists ========================================================================

## Web::CSS::ExpandedGridTracksAndLines (Libraries/LibWeb/CSS/Interpolation.cpp:535).
struct CssExpandedGridTracksAndLines:
    var tracks: ak.Vector[CssExplicitGridTrack]
    var line_names: ak.Vector[CssGridLineNames?]

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:540 Web::CSS::expand_grid_tracks_and_lines.
func css_expand_grid_tracks_and_lines(list: const CssGridTrackSizeList*) -> CssExpandedGridTracksAndLines:
    var result = CssExpandedGridTracksAndLines()
    var current_track: CssExplicitGridTrack? = none
    var current_line_names: CssGridLineNames? = none

    let components = css_grid_track_size_list_list(list)
    for component in ak.vector_span_const(&components):
        match component:
            .css_grid_line_names(grid_line_names):
                assert(current_line_names == none)
                current_line_names = grid_line_names
            .css_explicit_grid_track(grid_track):
                if let track = current_track:
                    # append_result()
                    ak.vector_append_t(&result.tracks, track)
                    ak.vector_append_t(&result.line_names, current_line_names)
                    current_track = none
                    current_line_names = none

                current_track = grid_track
        if current_track != none and current_line_names != none:
            # append_result()
            ak.vector_append_t(&result.tracks, current_track else trap("unreachable: checked above"))
            ak.vector_append_t(&result.line_names, current_line_names)
            current_track = none
            current_line_names = none
    if let track = current_track:
        # append_result()
        ak.vector_append_t(&result.tracks, track)
        ak.vector_append_t(&result.line_names, current_line_names)

    return result

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:571 Web::CSS::append_grid_track_with_line_names.
func css_append_grid_track_with_line_names(list: CssGridTrackSizeList*, track: CssExplicitGridTrack, line_names: CssGridLineNames?):
    css_grid_track_size_list_append_css_explicit_grid_track(list, track)
    if let names = line_names:
        css_grid_track_size_list_append_css_grid_line_names(list, names)

## interpolate_grid_track_size_list's `interpolate_grid_size` lambda.
func css_interpolate_grid_size(element: DomElement*, calculation_context: const CssCalculationContext*, from_grid_size: CssGridSize, to_grid_size: CssGridSize, delta: f32) -> CssGridSize:
    let interpolated = css_interpolate_value(element, calculation_context, css_grid_size_style_value(&from_grid_size), css_grid_size_style_value(&to_grid_size), delta, CssAllowDiscrete.yes) else trap("a null interpolated grid size")
    return css_grid_size_new(interpolated)

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:578 Web::CSS::interpolate_grid_track_size_list.
func css_interpolate_grid_track_size_list(element: DomElement*, calculation_context: const CssCalculationContext*, from_: const CssGridTrackSizeList*, to: const CssGridTrackSizeList*, delta: f32) -> CssGridTrackSizeList?:
    let expanded_from = css_expand_grid_tracks_and_lines(from_)
    let expanded_to = css_expand_grid_tracks_and_lines(to)

    if ak.vector_size(&expanded_from.tracks) != ak.vector_size(&expanded_to.tracks):
        return none

    var result = CssGridTrackSizeList()
    for i in 0..<ak.vector_size(&expanded_from.tracks):
        let from_track = *ak.vector_at_const(&expanded_from.tracks, i)
        let to_track = *ak.vector_at_const(&expanded_to.tracks, i)
        let interpolated_line_names = *ak.vector_at_const(&expanded_from.line_names, i) if delta < 0.5 else *ak.vector_at_const(&expanded_to.line_names, i)

        if css_explicit_grid_track_is_repeat(&from_track) or css_explicit_grid_track_is_repeat(&to_track):
            # https://drafts.csswg.org/css-grid/#repeat-interpolation
            if not css_explicit_grid_track_is_repeat(&from_track) or not css_explicit_grid_track_is_repeat(&to_track):
                return none

            let from_repeat = css_explicit_grid_track_repeat(&from_track)
            let to_repeat = css_explicit_grid_track_repeat(&to_track)
            if not css_grid_repeat_is_fixed(&from_repeat) or not css_grid_repeat_is_fixed(&to_repeat):
                return none
            let from_repeat_list = css_grid_repeat_grid_track_size_list(&from_repeat)
            let to_repeat_list = css_grid_repeat_grid_track_size_list(&to_repeat)
            let from_repeat_tracks = css_grid_track_size_list_track_list(&from_repeat_list)
            let to_repeat_tracks = css_grid_track_size_list_track_list(&to_repeat_list)
            if css_grid_repeat_repeat_count(&from_repeat) != css_grid_repeat_repeat_count(&to_repeat) or ak.vector_size(&from_repeat_tracks) != ak.vector_size(&to_repeat_tracks):
                return none

            let interpolated_repeat_grid_tracks = css_interpolate_grid_track_size_list(element, calculation_context, &from_repeat_list, &to_repeat_list, delta) else return none

            var repeat: CssGridRepeat = ---
            css_grid_repeat_construct_css_grid_repeat_type(&repeat, css_grid_repeat_type(&from_repeat), interpolated_repeat_grid_tracks, css_integer_style_value_create((i32)css_grid_repeat_repeat_count(&from_repeat)).css_style_value())
            let interpolated_grid_track = css_explicit_grid_track_new(.css_grid_repeat(repeat))
            css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
        elif css_explicit_grid_track_is_minmax(&from_track) and css_explicit_grid_track_is_minmax(&to_track):
            let from_minmax = css_explicit_grid_track_minmax(&from_track)
            let to_minmax = css_explicit_grid_track_minmax(&to_track)
            let interpolated_min = css_interpolate_grid_size(element, calculation_context, css_grid_min_max_min_grid_size(&from_minmax), css_grid_min_max_min_grid_size(&to_minmax), delta)
            let interpolated_max = css_interpolate_grid_size(element, calculation_context, css_grid_min_max_max_grid_size(&from_minmax), css_grid_min_max_max_grid_size(&to_minmax), delta)
            var minmax: CssGridMinMax = ---
            css_grid_min_max_construct(&minmax, interpolated_min, interpolated_max)
            let interpolated_grid_track = css_explicit_grid_track_new(.css_grid_min_max(minmax))
            css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
        elif css_explicit_grid_track_is_default(&from_track) and css_explicit_grid_track_is_default(&to_track):
            let from_grid_size = css_explicit_grid_track_grid_size(&from_track)
            let to_grid_size = css_explicit_grid_track_grid_size(&to_track)
            let interpolated_grid_size = css_interpolate_grid_size(element, calculation_context, from_grid_size, to_grid_size, delta)
            let interpolated_grid_track = css_explicit_grid_track_new(.css_grid_size(interpolated_grid_size))
            css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
        else:
            let interpolated_grid_track = from_track if delta < 0.5 else to_track
            css_append_grid_track_with_line_names(&result, interpolated_grid_track, interpolated_line_names)
    return result

# mark: interpolate_property ====================================================================

## interpolate_property's `static oblique_0deg_value`.
var css_interpolate_property_oblique_0deg_value: CssStyleValue*?

## `FontStyleStyleValue::create(FontStyleKeyword::Oblique, AngleStyleValue::create(Angle::make_degrees(0)))`.
func css_interpolate_property_make_oblique_0deg_value() -> CssStyleValue*:
    return css_font_style_style_value_create(css_data.FontStyleKeyword.oblique, css_angle_style_value_create(css_angle_make_degrees(0.0)).css_style_value()).css_style_value()

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:635 Web::CSS::interpolate_property.
pub func css_interpolate_property(element: DomElement*, property_id: css_data.PropertyId, a_from: CssStyleValue*, a_to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
    let from_ = css_with_keyword_values_resolved(element, property_id, a_from)
    let to = css_with_keyword_values_resolved(element, property_id, a_to)

    let calculation_context = css_calculation_context_for_property(css_property_name_and_id_from_id(property_id))

    let animation_type = css_data.animation_type_from_longhand_property(property_id)
    match animation_type:
        .by_computed_value:
            return css_interpolate_value(element, &calculation_context, from_, to, delta, allow_discrete)
        .none_:
            return to
        .repeatable_list:
            return css_interpolate_repeatable_list(element, &calculation_context, from_, to, delta, allow_discrete)
        .custom:
            return css_interpolate_custom_property(element, &calculation_context, property_id, from_, to, delta, allow_discrete)
        _:
            # case AnimationType::Discrete: default:
            return css_interpolate_discrete(from_, to, delta, allow_discrete)

## The `case AnimationType::Custom` of interpolate_property, with its fallthrough to discrete.
func css_interpolate_custom_property(element: DomElement*, calculation_context: const CssCalculationContext*, property_id: css_data.PropertyId, from_: CssStyleValue*, to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
    if property_id == css_data.PropertyId.transform:
        if let interpolated_transform = css_interpolate_transform(element, calculation_context, from_, to, delta, allow_discrete):
            return interpolated_transform

        # https://drafts.csswg.org/css-transforms-1/#interpolation-of-transforms
        # In some cases, an animation might cause a transformation matrix to be singular or non-invertible.
        # For example, an animation in which scale moves from 1 to -1. At the time when the matrix is in
        # such a state, the transformed element is not rendered.
        return none
    if property_id == css_data.PropertyId.box_shadow or property_id == css_data.PropertyId.text_shadow:
        if let interpolated_box_shadow = css_interpolate_box_shadow(element, calculation_context, from_, to, delta, allow_discrete):
            return interpolated_box_shadow
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    if property_id == css_data.PropertyId.font_style:
        let oblique_0deg_value = css_interpolation_static_value(&css_interpolate_property_oblique_0deg_value, css_interpolate_property_make_oblique_0deg_value)
        let from_value = oblique_0deg_value if css_font_style_style_value_font_style(css_style_value_as_font_style(from_)) == css_data.FontStyleKeyword.normal else from_
        let to_value = oblique_0deg_value if css_font_style_style_value_font_style(css_style_value_as_font_style(to)) == css_data.FontStyleKeyword.normal else to
        return css_interpolate_value(element, calculation_context, from_value, to_value, delta, allow_discrete)

    if property_id == css_data.PropertyId.font_variation_settings:
        # https://drafts.csswg.org/css-fonts/#font-variation-settings-def
        # Two declarations of font-feature-settings can be animated between if they are "like". "Like" declarations
        # are ones where the same set of properties appear (in any order). Because successive duplicate properties
        # are applied instead of prior duplicate properties, two declarations can be "like" even if they have
        # differing number of properties. If two declarations are "like" then animation occurs pairwise between
        # corresponding values in the declarations. Otherwise, animation is not possible.
        if not css_style_value_is_value_list(from_) or not css_style_value_is_value_list(to):
            return css_interpolate_discrete(from_, to, delta, allow_discrete)

        # The values in these lists have already been deduplicated and sorted at this point, so we can use
        # interpolate_value() to interpolate them pairwise.
        return css_interpolate_value(element, calculation_context, from_, to, delta, allow_discrete)

    # https://drafts.csswg.org/web-animations-1/#animating-visibility
    if property_id == css_data.PropertyId.visibility:
        # For the visibility property, visible is interpolated as a discrete step where values of p between 0 and 1 map to visible and other values of p map to the closer endpoint.
        # If neither value is visible, then discrete animation is used.
        if css_style_value_equals(from_, to):
            return from_

        let from_is_visible = css_style_value_to_keyword(from_) == css_data.Keyword.visible
        let to_is_visible = css_style_value_to_keyword(to) == css_data.Keyword.visible

        if from_is_visible or to_is_visible:
            if delta <= 0.0:
                return from_
            if delta >= 1.0:
                return to
            return css_keyword_style_value_create(css_data.Keyword.visible).css_style_value()

        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    # https://drafts.csswg.org/css-contain/#content-visibility-animation
    if property_id == css_data.PropertyId.content_visibility:
        # In general, the content-visibility property’s animation type is discrete.
        # However, similar to interpolation of visibility, during interpolation between hidden and any other content-visibility value,
        # p values between 0 and 1 map to the non-hidden value.
        if css_style_value_equals(from_, to):
            return from_

        let from_is_hidden = css_style_value_to_keyword(from_) == css_data.Keyword.hidden
        let to_is_hidden = css_style_value_to_keyword(to) == css_data.Keyword.hidden

        if from_is_hidden or to_is_hidden:
            let non_hidden_value = to if from_is_hidden else from_
            if delta <= 0.0:
                return from_
            if delta >= 1.0:
                return to
            return non_hidden_value
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    # https://drafts.csswg.org/css-display-4/#display-animation
    if property_id == css_data.PropertyId.display:
        # In general, the display property’s animation type is discrete. However, similar to interpolation of
        # visibility (see Web Animations §  Animation of visibility), during interpolation between none and any
        # other display value, p values between 0 and 1 map to the non-none value. Additionally, the element is
        # inert as long as its display value would compute to none when ignoring the Transitions and Animations
        # cascade origins.
        # FIXME: Implement the inertness portion of this.

        if css_style_value_equals(from_, to):
            return from_

        let from_display = css_display_style_value_display(css_style_value_as_display(from_))
        let to_display = css_display_style_value_display(css_style_value_as_display(to))
        let from_is_none = css_display_is_none(&from_display)
        let to_is_none = css_display_is_none(&to_display)

        if from_is_none or to_is_none:
            let non_none_value = to if from_is_none else from_
            if delta <= 0.0:
                return from_
            if delta >= 1.0:
                return to
            return non_none_value

        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    if property_id == css_data.PropertyId.scale:
        if let result = css_interpolate_scale(element, calculation_context, from_, to, delta, allow_discrete):
            return result
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    if property_id == css_data.PropertyId.translate:
        if let result = css_interpolate_translate(element, calculation_context, from_, to, delta, allow_discrete):
            return result
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    if property_id == css_data.PropertyId.rotate:
        if let result = css_interpolate_rotate(element, calculation_context, from_, to, delta, allow_discrete):
            return result
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    if property_id == css_data.PropertyId.filter or property_id == css_data.PropertyId.backdrop_filter:
        if let result = css_interpolate_filter_value_list(element, calculation_context, from_, to, delta, allow_discrete):
            return result
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    if property_id == css_data.PropertyId.grid_template_rows or property_id == css_data.PropertyId.grid_template_columns:
        # https://drafts.csswg.org/css-grid/#track-sizing
        # If the list lengths match, by computed value type per item in the computed track list.
        let from_list = css_grid_track_size_list_style_value_grid_track_size_list(css_style_value_as_grid_track_size_list(from_))
        let to_list = css_grid_track_size_list_style_value_grid_track_size_list(css_style_value_as_grid_track_size_list(to))

        let interpolated_grid_tack_size_list = css_interpolate_grid_track_size_list(element, calculation_context, &from_list, &to_list, delta) else return css_interpolate_discrete(from_, to, delta, allow_discrete)

        return css_grid_track_size_list_style_value_create(interpolated_grid_tack_size_list).css_style_value()

    if property_id == css_data.PropertyId.stroke_dasharray:
        # https://svgwg.org/svg2-draft/painting.html#StrokeDashing
        # If either start or end compute to none or are invalid, start or end are combined using the discrete animation type.
        if not css_style_value_is_value_list(from_) or not css_style_value_is_value_list(to):
            return css_interpolate_discrete(from_, to, delta, allow_discrete)

        # Otherwise, repeat both dash patterns of start and end value list until the length of elements in
        # both value lists match. Each item is then combined by computed value.
        if let result = css_interpolate_repeatable_list(element, calculation_context, from_, to, delta, allow_discrete):
            return result
        return css_interpolate_discrete(from_, to, delta, allow_discrete)

    # FIXME: Handle all custom animatable properties
    # [[fallthrough]] to AnimationType::Discrete
    return css_interpolate_discrete(from_, to, delta, allow_discrete)

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:819 Web::CSS::property_values_are_transitionable.
# https://drafts.csswg.org/css-transitions/#transitionable
pub func css_property_values_are_transitionable(property_id: css_data.PropertyId, old_value: CssStyleValue*, new_value: CssStyleValue*, element: DomElement*, transition_behavior: css_data.TransitionBehavior) -> bool:
    # When comparing the before-change style and after-change style for a given property,
    # the property values are transitionable if they have an animation type that is neither not animatable nor discrete.

    let animation_type = css_data.animation_type_from_longhand_property(property_id)
    if animation_type == css_data.AnimationType.none_ or (transition_behavior != css_data.TransitionBehavior.allow_discrete and animation_type == css_data.AnimationType.discrete):
        return false

    # Even when a property is transitionable, the two values may not be. The spec uses the example of inset/non-inset shadows.
    if transition_behavior != css_data.TransitionBehavior.allow_discrete and css_interpolate_property(element, property_id, old_value, new_value, 0.5, CssAllowDiscrete.no) == none:
        return false

    return true