Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / invalidation / language_invalidator.lucb

#==============================================================================================
#
#   language_invalidator - style invalidation after an element's lang or dir, or the text that
#                          dir=auto resolves from, changes
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Invalidation/LanguageInvalidator.cpp (lines 1-70).
#
#       Copyright (c) 2026-present, the Ladybird developers
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## invalidate_descendants_affected_by_language_or_directionality's for_each_shadow_including_inclusive_descendant
## callback; its capture is `is_directionality_change`.
func css_invalidation_invalidate_language_or_directionality_of(context: void*?, node: DomNode*) -> TraversalDecision:
    let is_directionality_change = *(const bool*)(context else trap("no captures"))
    if let element = as_if_dom_element(node):
        if not is_directionality_change:
            dom_element_invalidate_lang_value(element)
        dom_node_set_needs_style_update(element.dom_node(), true)
    return TraversalDecision.continue_

## The captures of invalidate_descendants_affected_by_language_or_directionality's
## for_each_style_scope_which_may_observe_the_node lambda.
struct CssInvalidationLanguageOrDirectionalityScopes:
    var element: DomElement*
    var is_directionality_change: bool

## invalidate_descendants_affected_by_language_or_directionality's for_each_style_scope_which_may_observe_the_node
## lambda.
func css_invalidation_schedule_language_or_directionality_has(context: void*?, scope: CssStyleScope*):
    let captures = (CssInvalidationLanguageOrDirectionalityScopes*)(context else trap("no captures"))
    let pseudo_class = css_data.PseudoClass.dir if captures.is_directionality_change else css_data.PseudoClass.lang
    var properties: ak.Vector[CssInvalidationSetProperty]
    ak.vector_append_t(&properties, CssInvalidationSetProperty(type_ = CssInvalidationSetPropertyType.pseudo_class, value = FlyStringOrPseudoClassOrEmpty.pseudo_class(pseudo_class)))
    css_style_scope_record_pending_has_invalidation_mutation_features_vector(scope, captures.element.dom_node(), &properties)
    css_style_scope_schedule_ancestors_style_invalidation_due_to_presence_of_has(scope, captures.element.dom_node())

## Ported from Libraries/LibWeb/CSS/Invalidation/LanguageInvalidator.cpp:16 Web::CSS::Invalidation::invalidate_descendants_affected_by_language_or_directionality.
func css_invalidation_invalidate_descendants_affected_by_language_or_directionality(element: DomElement*, is_directionality_change: bool):
    # dir and lang both inherit, so all descendants' :dir() / :lang() matches and direction-dependent layout/text
    # need to be recomputed.
    var is_directionality_change_capture = is_directionality_change
    _ = dom_node_for_each_shadow_including_inclusive_descendant(element.dom_node(), ak.Function1[DomNode*, TraversalDecision](call = css_invalidation_invalidate_language_or_directionality_of, context = &is_directionality_change_capture))

    # :has(:dir(...)) and :has(:lang(...)) on ancestors aren't keyed on any property the regular invalidation
    # plan tracks, so explicitly schedule the :has() ancestor walk here.
    var captures = CssInvalidationLanguageOrDirectionalityScopes(element = element, is_directionality_change = is_directionality_change)
    dom_node_for_each_style_scope_which_may_observe_the_node(element.dom_node(), ak.Function1[CssStyleScope*, unit](call = css_invalidation_schedule_language_or_directionality_has, context = &captures))

## Ported from Libraries/LibWeb/CSS/Invalidation/LanguageInvalidator.cpp:41 Web::CSS::Invalidation::invalidate_style_after_language_change.
pub func css_invalidation_invalidate_style_after_language_change(element: DomElement*):
    css_invalidation_invalidate_descendants_affected_by_language_or_directionality(element, false)

## Ported from Libraries/LibWeb/CSS/Invalidation/LanguageInvalidator.cpp:46 Web::CSS::Invalidation::invalidate_style_after_directionality_change.
pub func css_invalidation_invalidate_style_after_directionality_change(element: DomElement*):
    css_invalidation_invalidate_descendants_affected_by_language_or_directionality(element, true)

## The captures of invalidate_style_after_text_directionality_change's for_each_style_scope_which_may_observe_the_node
## lambda.
struct CssInvalidationTextDirectionalityScopes:
    var ancestor: DomElement*
    var properties: ak.Vector[CssInvalidationSetProperty]

## invalidate_style_after_text_directionality_change's for_each_style_scope_which_may_observe_the_node lambda.
func css_invalidation_record_text_directionality_features(context: void*?, scope: CssStyleScope*):
    let captures = (CssInvalidationTextDirectionalityScopes*)(context else trap("no captures"))
    css_style_scope_record_pending_has_invalidation_mutation_features_vector(scope, captures.ancestor.dom_node(), &captures.properties)

## Ported from Libraries/LibWeb/CSS/Invalidation/LanguageInvalidator.cpp:51 Web::CSS::Invalidation::invalidate_style_after_text_directionality_change.
pub func css_invalidation_invalidate_style_after_text_directionality_change(character_data: DomCharacterData*):
    # dir=auto resolves an element's effective directionality from its text content, so any ancestor with dir=auto
    # can flip its :dir() match when this text changes. Recompute style on each such ancestor's subtree and propagate
    # :has(:dir(...)) invalidation up its ancestor chain.
    var ancestor = dom_node_parent_element(character_data.dom_node())
    while let current = ancestor:
        ancestor = dom_node_parent_element(current.dom_node())
        if dom_element_dir(current) != DomElementDir.auto:
            continue
        var captures = CssInvalidationTextDirectionalityScopes(ancestor = current)
        ak.vector_append_t(&captures.properties, CssInvalidationSetProperty(type_ = CssInvalidationSetPropertyType.pseudo_class, value = FlyStringOrPseudoClassOrEmpty.pseudo_class(css_data.PseudoClass.dir)))
        ak.vector_append_t(&captures.properties, CssInvalidationSetProperty(type_ = CssInvalidationSetPropertyType.pseudo_class, value = FlyStringOrPseudoClassOrEmpty.pseudo_class(css_data.PseudoClass.empty)))
        dom_node_for_each_style_scope_which_may_observe_the_node(current.dom_node(), ak.Function1[CssStyleScope*, unit](call = css_invalidation_record_text_directionality_features, context = &captures))
        css_invalidation_invalidate_descendants_affected_by_language_or_directionality(current, true)