Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / css_container_rule.lucb

#==============================================================================================
#
#   css_container_rule - CSS::CSSContainerRule: an @container rule
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/CSSContainerRule.cpp (lines 1-229) and the declarations of
#       CSSContainerRule.h (lines 17-54): its conditions (container name and query), their
#       serialization, and the global at-rules inside it, which are always effective.
#
#       Copyright (c) 2026, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:18 Web::CSS::CSSContainerRule::create.
pub func css_container_rule_create(realm: Realm*, conditions: ak.Vector[CssContainerRuleCondition], rules: CssRuleList*) -> CssContainerRule*:
    return realm_create_css_container_rule(realm, realm, conditions, rules)

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:23 Web::CSS::CSSContainerRule::CSSContainerRule.
pub func css_container_rule_construct(this: CssContainerRule*, realm: Realm*, conditions: ak.Vector[CssContainerRuleCondition], rules: CssRuleList*):
    css_condition_rule_construct(this.css_condition_rule(), realm, rules, CssRuleType.container)
    this.m_conditions = conditions

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:31 Web::CSS::CSSContainerRule::initialize (override).
pub func css_container_rule_initialize_impl(base: JsCell*, realm: Realm*):
    web_set_prototype_for_interface(base, realm, BindInterfaceName.css_container_rule)
    css_condition_rule_initialize_impl(base, realm)

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:38 Web::CSS::CSSContainerRule::condition_text (override).
# https://drafts.csswg.org/css-conditional-5/#the-csscontainerrule-interface
pub func css_container_rule_condition_text_impl(base: CssConditionRule*) -> ak.String:
    let this = (CssContainerRule*)base
    # The conditionText attribute (defined on the CSSConditionRule parent rule), on getting, must return a value as
    # follows:

    # 1. Let conditions be the result of getting the conditions attribute.
    let conditions = css_container_rule_conditions(this)

    # 2. Let first be true.
    var first = true

    # 2. Let result be the empty string.
    var result = ak.string_builder_new()

    # 3. For each condition in conditions:
    for condition in ak.vector_span_const(&conditions):
        # 1. If first is false, append ", " to result.
        if not first:
            ak.string_builder_append(&result, ", ")

        # 2. Set first to false.
        first = false

        # 3. If condition's name is not empty:
        if not ak.string_is_empty(&condition.name):
            # 1. Append condition's name to result.
            ak.string_builder_append_string_view(&result, ak.string_bytes_as_string_view(&condition.name))

            # 2. If condition's query is not empty, append a single space to result.
            if not ak.string_is_empty(&condition.query):
                ak.string_builder_append_u8(&result, ' ')

        # 4. Append condition's query to result.
        ak.string_builder_append_string_view(&result, ak.string_bytes_as_string_view(&condition.query))

    # 5. Return result.
    return ak.string_builder_to_string_without_validation(&result)

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:79 Web::CSS::CSSContainerRule::condition_matches (override).
pub func css_container_rule_condition_matches_impl(base: CssConditionRule*) -> bool:
    _ = base
    # NB: @container is processed differently from other CSSConditionRules. As such this is never called.
    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:86 Web::CSS::CSSContainerRule::serialized (override).
# https://drafts.csswg.org/cssom-1/#serialize-a-css-rule
pub func css_container_rule_serialized_impl(base: CssRule*) -> ak.String:
    let this = (CssContainerRule*)base
    let rules = css_grouping_rule_css_rules(this.css_grouping_rule())

    # AD-HOC: The spec does not define @container serialization, so this is based on CSSMediaRule::serialized().
    var builder = ak.string_builder_new()
    ak.string_builder_append(&builder, "@container ")

    let condition_text = css_condition_rule_condition_text(this.css_condition_rule())
    ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&condition_text))

    ak.string_builder_append(&builder, " {\n")

    for i in 0..<css_rule_list_length(rules):
        let rule = css_rule_list_item(rules, i) else trap("null rule")
        let result = css_rule_css_text(rule)

        if ak.string_is_empty(&result):
            continue

        ak.string_builder_append(&builder, "  ")
        ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&result))
        ak.string_builder_append_u8(&builder, '\n')

    ak.string_builder_append_u8(&builder, '}')

    return ak.string_builder_to_string_without_validation(&builder)

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:114 Web::CSS::CSSContainerRule::container_name.
# https://drafts.csswg.org/css-conditional-5/#dom-csscontainerrule-containername
pub func css_container_rule_container_name(this: CssContainerRule*) -> ak.String:
    # The containerName attribute, on getting, must return a value as follows:

    # 1. Let conditions be the result of getting the conditions attribute.
    let conditions = css_container_rule_conditions(this)

    # 2. If the length of conditions is 1:
    if ak.vector_size(&conditions) == 1:
        # 1. Return the only condition's name.
        return ak.vector_first_const(&conditions).name

    # 3. Return "".
    return ak.string_from_str("")

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:132 Web::CSS::CSSContainerRule::container_query.
# https://drafts.csswg.org/css-conditional-5/#dom-csscontainerrule-containerquery
pub func css_container_rule_container_query(this: CssContainerRule*) -> ak.String:
    # The containerQuery attribute, on getting, must return a value as follows:

    # 1. Let conditions be the result of getting the conditions attribute.
    let conditions = css_container_rule_conditions(this)

    # 2. If the length of conditions is 1:
    if ak.vector_size(&conditions) == 1:
        # 1. Return the only condition's query.
        return ak.vector_first_const(&conditions).query

    # 3. Return "".
    return ak.string_from_str("")

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:142 Web::CSS::CSSContainerRule::conditions.
# https://drafts.csswg.org/css-conditional-5/#dom-csscontainerrule-conditions
pub func css_container_rule_conditions(this: CssContainerRule*) -> ak.Vector[CssContainerCondition]:
    # The conditions attribute, on getting, must return a value as follows:

    # 1. Let result be an empty list.
    var result: ak.Vector[CssContainerCondition]

    # 2. For each <container-condition> condition specified in the rule:
    ak.vector_ensure_capacity(&result, ak.vector_size(&this.m_conditions))
    for condition in ak.vector_span(&this.m_conditions):
        # 1. Let dict be a new CSSContainerCondition with name set to the serialized <container-name> of condition if
        #    specified, or "" otherwise, and query set to the <container-query> specified in condition without any
        #    logical simplifications, so that the returned query will evaluate to the same result as the specified
        #    query in any conformant implementation of this specification (including implementations that implement
        #    future extensions allowed by the <general-enclosed> extensibility mechanism in this specification). In
        #    other words, token stream simplifications are allowed (such as reducing whitespace to a single space or
        #    omitting it in cases where it is known to be optional), but logical simplifications (such as removal of
        #    unneeded parentheses, or simplification based on evaluating results) are not allowed.
        var name = ak.string_from_str("")
        if let container_name = condition.container_name:
            name = css_syntax.serialize_an_identifier_string_view(ak.fly_string_bytes_as_string_view(&container_name))
        var query = ak.string_from_str("")
        if let container_query = condition.container_query:
            query = css_container_query_to_string(container_query)
        let dict = CssContainerCondition(name = name, query = query)

        # 2. Append dict to result.
        ak.vector_unchecked_append_u(&result, dict)

    # 3. Return result.
    return result

## Ported from Libraries/LibWeb/CSS/CSSContainerRule.cpp:181 Web::CSS::CSSContainerRule::for_each_effective_rule (override).
pub func css_container_rule_for_each_effective_rule_impl(base: CssGroupingRule*, order: TraversalOrder, callback: ak.Function1[CssRule*, unit]):
    # https://drafts.csswg.org/css-conditional-5/#container-rule
    # Global, name-defining at-rules such as @keyframes or @font-face or @layer that are defined inside container
    # queries are not constrained by the container query conditions.

    # NB: Due to how @container queries are applied to an element instead of globally, this method only treats those
    #     global, name-defining at-rules as effective.
    # FIXME: Is this right?
    for rule in ak.vector_span(&css_grouping_rule_css_rules(base).m_rules):
        match css_rule_type(rule):
            # These are not valid inside @container.
            .import_, .function_declarations, .namespace, .keyframe:
                _ = rule

            # These are effective if the container rule is effective, which is not handled in this method.
            .container, .media, .nested_declarations, .style, .supports:
                _ = rule

            # These are global and always effective.
            .counter_style, .font_face, .font_feature_values, .function, .keyframes, .layer_block, .layer_statement, .margin, .page, .property:
                if order == TraversalOrder.preorder:
                    ak.function1_call(&callback, rule)
                if let grouping_rule = as_if_css_grouping_rule(rule):
                    css_grouping_rule_for_each_effective_rule(grouping_rule, order, callback)
                if order == TraversalOrder.postorder:
                    ak.function1_call(&callback, rule)
            _:
                trap("VERIFY_NOT_REACHED")