Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / style_invalidation_data_2.lucb

#==============================================================================================
#
#   style_invalidation_data_2 - CSS::StyleInvalidationData II: building the invalidation sets
#                               and plans of a selector
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/StyleInvalidationData.cpp (lines 321-587): the invalidation set of a
#       group of simple selectors, the plans of each combinator, the scope leakage of complex
#       :is()/:where()/:not() arguments inside :has(), and
#       StyleInvalidationData::build_invalidation_sets_for_selector, which the rule cache runs
#       for every selector it holds.
#
#       Copyright (c) 2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Invalidation sets of simple selectors ===================================================

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:325 Web::CSS::should_register_invalidation_property.
func css_should_register_invalidation_property(property: const CssInvalidationSetProperty*) -> bool:
    return not (property.type_ == CssInvalidationSetPropertyType.invalidate_self or property.type_ == CssInvalidationSetPropertyType.invalidate_whole_subtree)

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:330 Web::CSS::build_invalidation_set_for_simple_selectors.
func css_build_invalidation_set_for_simple_selectors(simple_selectors: const ak.Vector[const CssSelectorSimpleSelector*]*, exclude_properties_nested_in_not_pseudo_class: CssExcludePropertiesNestedInNotPseudoClass, style_invalidation_data: CssStyleInvalidationData*, inside_nth_child_pseudo_class: CssInsideNthChildPseudoClass) -> CssInvalidationSet:
    var invalidation_set: CssInvalidationSet
    for simple_selector in ak.vector_span_const(simple_selectors):
        css_build_invalidation_sets_for_simple_selector(simple_selector, &invalidation_set, exclude_properties_nested_in_not_pseudo_class, style_invalidation_data, inside_nth_child_pseudo_class)
    return invalidation_set

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:338 Web::CSS::simple_selector_group_matches_any.
func css_simple_selector_group_matches_any(simple_selectors: const ak.Vector[const CssSelectorSimpleSelector*]*) -> bool:
    return ak.vector_size(simple_selectors) == 1 and ak.vector_span_const(simple_selectors)[0].type_ == CssSelectorSimpleSelectorType.universal

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:343 Web::CSS::make_invalidate_self_invalidation.
func css_make_invalidate_self_invalidation() -> CssInvalidationPlan*:
    let invalidation = css_invalidation_plan_create()
    invalidation.invalidate_self = true
    return invalidation

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:350 Web::CSS::make_invalidate_whole_subtree_invalidation.
func css_make_invalidate_whole_subtree_invalidation() -> CssInvalidationPlan*:
    let invalidation = css_invalidation_plan_create()
    invalidation.invalidate_whole_subtree = true
    return invalidation

## add_invalidation_plan_for_properties' `ensure` callback: `[] { return InvalidationPlan::create(); }`.
func css_add_invalidation_plan_for_properties_create(context: void*?) -> CssInvalidationPlan*:
    return css_invalidation_plan_create()

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:357 Web::CSS::add_invalidation_plan_for_properties.
func css_add_invalidation_plan_for_properties(style_invalidation_data: CssStyleInvalidationData*, invalidation_properties: const CssInvalidationSet*, plan: const CssInvalidationPlan*):
    for invalidation_property in css_invalidation_set_properties(invalidation_properties):
        if not css_should_register_invalidation_property(&invalidation_property):
            continue

        let stored_invalidation = ak.hash_map_ensure_t_callback(&style_invalidation_data.invalidation_plans, invalidation_property, ak.Function0[CssInvalidationPlan*](call = css_add_invalidation_plan_for_properties_create, context = none))
        css_invalidation_plan_include_all_from(*stored_invalidation, *plan)

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:377 Web::CSS::build_invalidation_for_combinator.
func css_build_invalidation_for_combinator(combinator: CssSelectorCombinator, righthand: const CssSelectorRighthand*) -> CssInvalidationPlan*:
    if righthand.payload.invalidate_whole_subtree or (not righthand.subject_matches_any and css_invalidation_set_is_empty(&righthand.subject_match_set)):
        return css_make_invalidate_whole_subtree_invalidation()

    let invalidation = css_invalidation_plan_create()
    match combinator:
        .immediate_child, .descendant:
            let rule = CssDescendantInvalidationRule(match_set = righthand.subject_match_set, match_any = righthand.subject_matches_any, payload = righthand.payload)
            css_append_or_merge_descendant_rule(&invalidation.descendant_rules, &rule)
        .next_sibling:
            let rule = CssSiblingInvalidationRule(reach = CssSiblingInvalidationReach.adjacent, match_set = righthand.subject_match_set, match_any = righthand.subject_matches_any, payload = righthand.payload)
            css_append_or_merge_sibling_rule(&invalidation.sibling_rules, &rule)
        .subsequent_sibling:
            let rule = CssSiblingInvalidationRule(reach = CssSiblingInvalidationReach.subsequent, match_set = righthand.subject_match_set, match_any = righthand.subject_matches_any, payload = righthand.payload)
            css_append_or_merge_sibling_rule(&invalidation.sibling_rules, &rule)
        _:
            invalidation.invalidate_whole_subtree = true
    return invalidation

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:401 Web::CSS::build_invalidation_sets_for_simple_selector.
pub func css_build_invalidation_sets_for_simple_selector(selector: const CssSelectorSimpleSelector*, invalidation_set: CssInvalidationSet*, exclude_properties_nested_in_not_pseudo_class: CssExcludePropertiesNestedInNotPseudoClass, style_invalidation_data: CssStyleInvalidationData*, inside_nth_child_selector: CssInsideNthChildPseudoClass):
    match selector.type_:
        .class_:
            css_invalidation_set_set_needs_invalidate_class(invalidation_set, css_selector_simple_selector_name(selector))
        .id:
            css_invalidation_set_set_needs_invalidate_id(invalidation_set, css_selector_simple_selector_name(selector))
        .tag_name:
            css_invalidation_set_set_needs_invalidate_tag_name(invalidation_set, css_selector_simple_selector_qualified_name(selector).name.lowercase_name)
        .attribute:
            css_invalidation_set_set_needs_invalidate_attribute(invalidation_set, css_selector_simple_selector_attribute(selector).qualified_name.name.lowercase_name)
        .pseudo_class:
            let pseudo_class = css_selector_simple_selector_pseudo_class(selector)
            # The C++ switch: the first group of cases falls through into the second.
            let covers_scope_leakage = match pseudo_class.type_:
                .enabled, .defined, .disabled, .empty, .placeholder_shown, .checked, .has => true
                _ => false
            let invalidates_pseudo_class = match pseudo_class.type_:
                .link, .any_link, .local_link, .required, .optional => true
                _ => false
            if covers_scope_leakage:
                for nested_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                    css_add_invalidation_sets_to_cover_scope_leakage_of_relative_selector_in_has_pseudo_class(nested_selector, style_invalidation_data)
                # [[fallthrough]]
            if covers_scope_leakage or invalidates_pseudo_class:
                css_invalidation_set_set_needs_invalidate_pseudo_class(invalidation_set, pseudo_class.type_)
            if pseudo_class.type_ == css_data.PseudoClass.has:
                return
            if exclude_properties_nested_in_not_pseudo_class == CssExcludePropertiesNestedInNotPseudoClass.yes and pseudo_class.type_ == css_data.PseudoClass.not_:
                return
            var inside_nth_child_pseudo_class_for_nested = inside_nth_child_selector
            let is_nth_pseudo_class = match pseudo_class.type_:
                .nth_child, .nth_last_child, .nth_of_type, .nth_last_of_type => true
                _ => false
            if is_nth_pseudo_class:
                inside_nth_child_pseudo_class_for_nested = CssInsideNthChildPseudoClass.yes
            for nested_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                let rightmost_invalidation_set_for_selector = css_build_invalidation_sets_for_selector_impl(style_invalidation_data, nested_selector, inside_nth_child_pseudo_class_for_nested)
                css_invalidation_set_include_all_from(invalidation_set, rightmost_invalidation_set_for_selector)

                # Propagate :has() from inner selectors where it appears in non-rightmost compounds.
                # The rightmost set only carries properties from the rightmost compound, so :has() in
                # non-rightmost positions (e.g., :is(:has(.x) .y)) is not propagated. We need it in the
                # outer invalidation set so outer compounds register plans for pseudo_class:Has that
                # account for the full selector context.
                # Additionally, when :has() is inside a complex :is()/:where() argument (multiple
                # compounds), the outer invalidation plan can't correctly capture the nested combinator
                # structure — e.g., sibling combinators at the outer level would be applied at the wrong
                # DOM level. Fall back to whole-subtree invalidation for :has() in these cases.
                if css_selector_contains_pseudo_class(nested_selector, css_data.PseudoClass.has):
                    css_invalidation_set_set_needs_invalidate_pseudo_class(invalidation_set, css_data.PseudoClass.has)
                    if ak.vector_size(&nested_selector.m_compound_selectors) > 1:
                        var has_only: CssInvalidationSet
                        css_invalidation_set_set_needs_invalidate_pseudo_class(&has_only, css_data.PseudoClass.has)
                        css_add_invalidation_plan_for_properties(style_invalidation_data, &has_only, css_make_invalidate_whole_subtree_invalidation())
        .pseudo_element:
            # Pseudo-elements like ::slotted(.x) and ::part(...) carry a compound selector argument whose simple
            # selectors decide which property changes should trigger invalidation against this rule.
            let pseudo_element = css_selector_simple_selector_pseudo_element(selector)
            if css_selector_pseudo_element_selector_type(&pseudo_element) == css_data.PseudoElement.slotted:
                let compound = css_selector_pseudo_element_selector_compound_selector(&pseudo_element)
                for compound_selector in &ak.vector_span_const(&compound.m_compound_selectors):
                    for nested_simple in &ak.vector_span_const(&compound_selector.simple_selectors):
                        css_build_invalidation_sets_for_simple_selector(nested_simple, invalidation_set, exclude_properties_nested_in_not_pseudo_class, style_invalidation_data, inside_nth_child_selector)
        _:
            return

## add_invalidation_sets_to_cover_scope_leakage_of_relative_selector_in_has_pseudo_class's
## `invalidate_whole_subtree_for_invalidation_properties_in_non_subject_part_of_complex_selector` lambda.
func css_invalidate_whole_subtree_for_invalidation_properties_in_non_subject_part_of_complex_selector(selector_to_invalidate: const CssSelector*, style_invalidation_data: CssStyleInvalidationData*):
    for group in css_for_each_consecutive_simple_selector_group(selector_to_invalidate):
        if group.is_rightmost:
            continue

        let invalidation_set = css_build_invalidation_set_for_simple_selectors(&group.simple_selectors, CssExcludePropertiesNestedInNotPseudoClass.no, style_invalidation_data, CssInsideNthChildPseudoClass.no)
        css_add_invalidation_plan_for_properties(style_invalidation_data, &invalidation_set, css_make_invalidate_whole_subtree_invalidation())

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:488 Web::CSS::add_invalidation_sets_to_cover_scope_leakage_of_relative_selector_in_has_pseudo_class.
func css_add_invalidation_sets_to_cover_scope_leakage_of_relative_selector_in_has_pseudo_class(selector: const CssSelector*, style_invalidation_data: CssStyleInvalidationData*):
    # Normally, :has() invalidation scope is limited to ancestors and ancestor siblings, however it could require
    # descendants invalidation when :is() with complex selector is used inside :has() relative selector.
    # For example ".a:has(:is(.b .c))" requires invalidation whenever "b" class is added or removed.
    # To cover this case, we add descendant invalidation set that requires whole subtree invalidation for each
    # property used in non-subject part of complex selector.

    for group in css_for_each_consecutive_simple_selector_group(selector):
        for simple_selector in ak.vector_span_const(&group.simple_selectors):
            if simple_selector.type_ != CssSelectorSimpleSelectorType.pseudo_class:
                continue
            let pseudo_class = css_selector_simple_selector_pseudo_class(simple_selector)
            if pseudo_class.type_ == css_data.PseudoClass.is or pseudo_class.type_ == css_data.PseudoClass.where or pseudo_class.type_ == css_data.PseudoClass.not_:
                for nested_selector in ak.vector_span_const(&pseudo_class.argument_selector_list):
                    css_invalidate_whole_subtree_for_invalidation_properties_in_non_subject_part_of_complex_selector(nested_selector, style_invalidation_data)

# mark: Invalidation sets of a selector =========================================================

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:519 Web::CSS::build_invalidation_sets_for_selector_impl.
func css_build_invalidation_sets_for_selector_impl(style_invalidation_data: CssStyleInvalidationData*, selector: const CssSelector*, inside_nth_child_pseudo_class: CssInsideNthChildPseudoClass) -> CssInvalidationSet:
    let compound_selector_index = (isize)ak.vector_size(&selector.m_compound_selectors) - 1
    assert(compound_selector_index >= 0)

    var invalidation_set_for_rightmost_selector: CssInvalidationSet
    var previous_compound_combinator = CssSelectorCombinator.none_
    var selector_righthand: CssSelectorRighthand? = none
    for group in css_for_each_consecutive_simple_selector_group(selector):
        let simple_selectors = &group.simple_selectors
        let combinator = group.combinator
        # Collect properties used in :has() so we can decide if only specific properties
        # trigger descendant invalidation or if the entire document must be invalidated.
        for simple_selector in ak.vector_span_const(simple_selectors):
            css_collect_properties_used_in_has(simple_selector, style_invalidation_data, none)

        let invalidation_properties = css_build_invalidation_set_for_simple_selectors(simple_selectors, CssExcludePropertiesNestedInNotPseudoClass.no, style_invalidation_data, inside_nth_child_pseudo_class)
        let subject_match_set = css_build_invalidation_set_for_simple_selectors(simple_selectors, CssExcludePropertiesNestedInNotPseudoClass.yes, style_invalidation_data, inside_nth_child_pseudo_class)
        let subject_matches_any = css_invalidation_set_is_empty(&subject_match_set) and css_simple_selector_group_matches_any(simple_selectors)

        if group.is_rightmost:
            # The rightmost selector is handled twice:
            #  1) Include properties nested in :not()
            #  2) Exclude properties nested in :not()
            #
            # This ensures we handle cases like:
            #   :not(.foo) => produce invalidation set .foo { $ } ($ = invalidate self)
            #   .bar :not(.foo) => produce invalidation sets .foo { $ } and .bar { * } (* = invalidate subtree)
            #                      which means invalidation_set_for_rightmost_selector should be empty
            let root_plan = css_make_invalidate_self_invalidation()
            if inside_nth_child_pseudo_class == CssInsideNthChildPseudoClass.yes:
                # When invalidation property is nested in nth-child selector like p:nth-child(even of #t1, #t2, #t3)
                # we need to make sure all affected siblings are invalidated.
                root_plan.invalidate_whole_subtree = true
            css_add_invalidation_plan_for_properties(style_invalidation_data, &invalidation_properties, root_plan)

            invalidation_set_for_rightmost_selector = subject_match_set
            selector_righthand = CssSelectorRighthand(subject_match_set = subject_match_set, subject_matches_any = subject_matches_any, payload = root_plan)
        else:
            assert(previous_compound_combinator != CssSelectorCombinator.none_)
            let righthand = selector_righthand else trap("VERIFY: selector_righthand.has_value()")

            let plan = css_build_invalidation_for_combinator(previous_compound_combinator, &righthand)
            css_add_invalidation_plan_for_properties(style_invalidation_data, &invalidation_properties, plan)

            selector_righthand = CssSelectorRighthand(subject_match_set = subject_match_set, subject_matches_any = subject_matches_any, payload = plan)

        previous_compound_combinator = combinator

    return invalidation_set_for_rightmost_selector

## Ported from Libraries/LibWeb/CSS/StyleInvalidationData.cpp:582 Web::CSS::StyleInvalidationData::build_invalidation_sets_for_selector.
pub func css_style_invalidation_data_build_invalidation_sets_for_selector(this: CssStyleInvalidationData*, selector: const CssSelector*):
    _ = css_build_invalidation_sets_for_selector_impl(this, selector, CssInsideNthChildPseudoClass.no)