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)