Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / counters_set.lucb

#==============================================================================================
#
#   counters_set - CSS::CountersSet: an element's CSS counters set and counter resolution
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/CountersSet.cpp (lines 1-219) and CountersSet.h's inline members:
#       instantiating, setting and incrementing counters, and the "resolve counters" and
#       "inherit counters" steps of css-lists-3.
#
#       Copyright (c) 2024-2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: CountersSet =============================================================================

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:16 Web::CSS::CountersSet::visit_edges.
pub func css_counters_set_visit_edges(this: CssCountersSet*, visitor: gc.CellVisitor*):
    for counter in ak.vector_span_const(&this.m_counters):
        dom_abstract_element_visit(&counter.originating_element, visitor)

## The captures of instantiate_a_counter's `remove_first_matching` predicate.
struct CssCountersSetInstantiateACounterMatch:
    var name: ak.FlyString
    var originating_element: DomAbstractElement

## instantiate_a_counter's `remove_first_matching` predicate: the innermost counter.
func css_counters_set_instantiate_a_counter_match(context: void*?, it: const CssCounter*) -> bool:
    let captures = (CssCountersSetInstantiateACounterMatch*)(context else trap("no captures"))
    return ak.fly_string_eq_fly_string(&it.name, &captures.name) and it.originating_element == captures.originating_element

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:23 Web::CSS::CountersSet::instantiate_a_counter.
# https://drafts.csswg.org/css-lists-3/#instantiate-counter
pub func css_counters_set_instantiate_a_counter(this: CssCountersSet*, name: ak.FlyString, element: DomAbstractElement, reversed: bool, value: i32?) -> CssCounter*:
    # 1. Let counters be element’s CSS counters set.

    # 2. Let innermost counter be the last counter in counters with the name name.
    #    If innermost counter’s originating element is element or a previous sibling of element,
    #    remove innermost counter from counters.
    if let innermost_counter = css_counters_set_last_counter_with_name(this, name):
        let innermost_element = innermost_counter.originating_element

        if innermost_element == element or (dom_abstract_element_parent_element(&innermost_element) == dom_abstract_element_parent_element(&element) and dom_abstract_element_is_before(&innermost_element, element)):
            var captures = CssCountersSetInstantiateACounterMatch(name = innermost_counter.name, originating_element = innermost_counter.originating_element)
            _ = ak.vector_remove_first_matching(&this.m_counters, ak.Function1[const CssCounter*, bool](call = css_counters_set_instantiate_a_counter_match, context = &captures))

    # 3. Append a new counter to counters with name name, originating element element,
    #    reversed being reversed, and initial value value (if given)
    ak.vector_append_t(&this.m_counters, CssCounter(
        name = name,
        originating_element = element,
        reversed = reversed,
        value = value,
    ))

    return ak.vector_last(&this.m_counters)

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:57 Web::CSS::CountersSet::set_a_counter.
# https://drafts.csswg.org/css-lists-3/#propdef-counter-set
pub func css_counters_set_set_a_counter(this: CssCountersSet*, name: ak.FlyString, element: DomAbstractElement, value: i32):
    if let existing_counter = css_counters_set_last_counter_with_name(this, name):
        existing_counter.value = value
        return

    # If there is not currently a counter of the given name on the element, the element instantiates
    # a new counter of the given name with a starting value of 0 before setting or incrementing its value.
    # https://drafts.csswg.org/css-lists-3/#valdef-counter-set-counter-name-integer
    let counter = css_counters_set_instantiate_a_counter(this, name, element, false, 0)
    counter.value = value

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:72 Web::CSS::CountersSet::increment_a_counter.
# https://drafts.csswg.org/css-lists-3/#propdef-counter-increment
pub func css_counters_set_increment_a_counter(this: CssCountersSet*, name: ak.FlyString, element: DomAbstractElement, amount: i32):
    if let existing_counter = css_counters_set_last_counter_with_name(this, name):
        # FIXME: How should we handle existing counters with no value? Can that happen?
        let existing_value = existing_counter.value else trap("VERIFY: the existing counter has a value")
        existing_counter.value = ak.saturating_add_i32(existing_value, amount)
        return

    # If there is not currently a counter of the given name on the element, the element instantiates
    # a new counter of the given name with a starting value of 0 before setting or incrementing its value.
    # https://drafts.csswg.org/css-lists-3/#valdef-counter-set-counter-name-integer
    let counter = css_counters_set_instantiate_a_counter(this, name, element, false, 0)
    counter.value = ak.saturating_add_i32(counter.value else trap("VERIFY: the counter has a value"), amount)

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:88 Web::CSS::CountersSet::last_counter_with_name.
pub func css_counters_set_last_counter_with_name(this: CssCountersSet*, name: ak.FlyString) -> CssCounter*?:
    var index = ak.vector_size(&this.m_counters)
    while index > 0:
        index -= 1
        let counter = ak.vector_at(&this.m_counters, index)
        if ak.fly_string_eq_fly_string(&counter.name, &name):
            return counter
    return none

## The captures of counter_with_same_name_and_creator's `first_matching` predicate.
struct CssCountersSetCounterWithSameNameAndCreatorMatch:
    var name: ak.FlyString
    var element: DomAbstractElement

## counter_with_same_name_and_creator's `first_matching` predicate.
func css_counters_set_counter_with_same_name_and_creator_match(context: void*?, it: const CssCounter*) -> bool:
    let captures = (CssCountersSetCounterWithSameNameAndCreatorMatch*)(context else trap("no captures"))
    return ak.fly_string_eq_fly_string(&it.name, &captures.name) and it.originating_element == captures.element

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:97 Web::CSS::CountersSet::counter_with_same_name_and_creator.
pub func css_counters_set_counter_with_same_name_and_creator(this: CssCountersSet*, name: ak.FlyString, element: DomAbstractElement) -> CssCounter*?:
    var captures = CssCountersSetCounterWithSameNameAndCreatorMatch(name = name, element = element)
    return ak.vector_first_matching(&this.m_counters, ak.Function1[const CssCounter*, bool](call = css_counters_set_counter_with_same_name_and_creator_match, context = &captures))

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:104 Web::CSS::CountersSet::append_copy.
pub func css_counters_set_append_copy(this: CssCountersSet*, counter: CssCounter):
    ak.vector_append_t(&this.m_counters, counter)

## Ported from Libraries/LibWeb/CSS/CountersSet.h:43 Web::CSS::CountersSet::counters.
pub func css_counters_set_counters(this: const CssCountersSet*) -> ak.Vector[CssCounter]:
    return this.m_counters

## Ported from Libraries/LibWeb/CSS/CountersSet.h:44 Web::CSS::CountersSet::is_empty.
pub func css_counters_set_is_empty(this: const CssCountersSet*) -> bool:
    return ak.vector_is_empty(&this.m_counters)

# mark: Resolving and inheriting counters =======================================================

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:110 Web::CSS::resolve_counters.
# https://drafts.csswg.org/css-lists-3/#auto-numbering
pub func css_resolve_counters(element_reference: DomAbstractElement*):
    # Resolving counter values on a given element is a multi-step process:
    let style = dom_abstract_element_computed_properties(element_reference) else trap("VERIFY: the element has computed properties")

    # 1. Existing counters are inherited from previous elements.
    css_inherit_counters(element_reference)

    # https://drafts.csswg.org/css-lists-3/#counters-without-boxes
    # An element that does not generate a box (for example, an element with display set to none,
    # or a pseudo-element with content set to none) cannot set, reset, or increment a counter.
    # The counter properties are still valid on such an element, but they must have no effect.
    let display = css_computed_properties_display(style)
    if css_display_is_none(&display):
        return

    # 2. New counters are instantiated (counter-reset).
    let counter_reset = css_computed_properties_counter_data(style, css_data.PropertyId.counter_reset)
    for counter in ak.vector_span_const(&counter_reset):
        _ = css_counters_set_instantiate_a_counter(dom_abstract_element_ensure_counters_set(element_reference), counter.name, *element_reference, counter.is_reversed, counter.value)

    # FIXME: Take style containment into account
    # https://drafts.csswg.org/css-contain-2/#containment-style
    # Giving an element style containment has the following effects:
    # 1. The 'counter-increment' and 'counter-set' properties must be scoped to the element’s sub-tree and create a
    #    new counter.

    # 3. Counter values are incremented (counter-increment).
    let counter_increment = css_computed_properties_counter_data(style, css_data.PropertyId.counter_increment)
    for counter in ak.vector_span_const(&counter_increment):
        css_counters_set_increment_a_counter(dom_abstract_element_ensure_counters_set(element_reference), counter.name, *element_reference, counter.value else trap("VERIFY: counter-increment has a value"))

    # 4. Counter values are explicitly set (counter-set).
    let counter_set = css_computed_properties_counter_data(style, css_data.PropertyId.counter_set)
    for counter in ak.vector_span_const(&counter_set):
        css_counters_set_set_a_counter(dom_abstract_element_ensure_counters_set(element_reference), counter.name, *element_reference, counter.value else trap("VERIFY: counter-set has a value"))

    # 5. Counter values are used (counter()/counters()).
    # NOTE: This happens when we process the `content` property.

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:151 Web::CSS::inherit_counters.
# https://drafts.csswg.org/css-lists-3/#inherit-counters
pub func css_inherit_counters(element_reference: DomAbstractElement*):
    # 1. If element is the root of its document tree, the element has an initially-empty CSS counters set.
    #    Return.
    let parent = dom_abstract_element_parent_element(element_reference)
    if parent == none:
        # NOTE: We represent an empty counters set with `m_counters_set = nullptr`.
        dom_abstract_element_set_counters_set(element_reference, none)
        return
    let parent_element = parent else trap("unreachable")

    # 2. Let element counters, representing element’s own CSS counters set, be a copy of the CSS counters
    #    set of element’s parent element.
    var element_counters: CssCountersSet*? = none
    # OPTIMIZATION: If parent has a set, we create a copy. Otherwise, we avoid allocating one until we need
    # to add something to it.
    if dom_element_has_non_empty_counters_set(parent_element):
        let parent_counters = dom_element_counters_set(parent_element) else trap("VERIFY: the parent has a counters set")
        element_counters = new CssCountersSet(m_counters = ak.vector_clone(&parent_counters.m_counters)) else trap("out of memory")

    # 3. Let sibling counters be the CSS counters set of element’s preceding sibling (if it has one),
    #    or an empty CSS counters set otherwise.
    #    For each counter of sibling counters, if element counters does not already contain a counter with
    #    the same name, append a copy of counter to element counters.
    if let sibling = dom_abstract_element_previous_sibling_in_tree_order(element_reference):
        if dom_abstract_element_has_non_empty_counters_set(&sibling):
            let sibling_counters = dom_abstract_element_counters_set(&sibling) else trap("VERIFY: the sibling has a counters set")
            # ensure_element_counters()
            if element_counters == none:
                element_counters = new CssCountersSet else trap("out of memory")
            let counters = element_counters else trap("unreachable")
            for counter in ak.vector_span_const(&sibling_counters.m_counters):
                if css_counters_set_last_counter_with_name(counters, counter.name) == none:
                    css_counters_set_append_copy(counters, counter)

    # 4. Let value source be the CSS counters set of the element immediately preceding element in tree order.
    #    For each source counter of value source, if element counters contains a counter with the same name
    #    and creator, then set the value of that counter to source counter’s value.
    if let previous = dom_abstract_element_previous_in_tree_order(element_reference):
        if dom_abstract_element_has_non_empty_counters_set(&previous):
            # NOTE: If element_counters is empty (AKA null) then we can skip this since nothing will match.
            if let counters = element_counters:
                let value_source = dom_abstract_element_counters_set(&previous) else trap("VERIFY: the previous element has a counters set")
                for source_counter in ak.vector_span_const(&value_source.m_counters):
                    if let maybe_existing_counter = css_counters_set_counter_with_same_name_and_creator(counters, source_counter.name, source_counter.originating_element):
                        maybe_existing_counter.value = source_counter.value

    if let counters = element_counters:
        assert(not css_counters_set_is_empty(counters))
    dom_abstract_element_set_counters_set(element_reference, element_counters)

## Ported from Libraries/LibWeb/CSS/CountersSet.cpp:208 Web::CSS::CountersSet::dump.
pub func css_counters_set_dump(this: const CssCountersSet*) -> ak.String:
    var builder = ak.string_builder_new()
    ak.string_builder_append(&builder, "{\n")
    for counter in ak.vector_span_const(&this.m_counters):
        let description = dom_abstract_element_debug_description(&counter.originating_element)
        # Formatter<Optional<T>> prints the value, or "None".
        let value = ak.arg_i64(i64(counter.value else 0)) if counter.value != none else ak.arg_str("None")
        css_appendff(&builder, "    {} ({}) = {}\n", [ak.arg_string_view(ak.fly_string_bytes_as_string_view(&counter.name)), ak.arg_string_view(ak.string_bytes_as_string_view(&description)), value])
    ak.string_builder_append(&builder, "}")
    return ak.string_builder_to_string_without_validation(&builder)