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)