Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / css_font_feature_values_rule.lucb

#==============================================================================================
#
#   css_font_feature_values_rule - CSS::CSSFontFeatureValuesRule: an @font-feature-values rule
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/CSSFontFeatureValuesRule.cpp (lines 1-173) and the inline members of
#       CSSFontFeatureValuesRule.h (lines 17-57): the font families, the seven feature value
#       maps (@annotation, @ornaments, ...), serialization and the font caches it invalidates.
#
#       Copyright (c) 2026, Callum Law <callumlaw1709@outlook.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: CSSFontFeatureValuesRule.h ==============================================================

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:28 Web::CSS::CSSFontFeatureValuesRule::annotation.
pub func css_font_feature_values_rule_annotation(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_annotation

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:29 Web::CSS::CSSFontFeatureValuesRule::ornaments.
pub func css_font_feature_values_rule_ornaments(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_ornaments

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:30 Web::CSS::CSSFontFeatureValuesRule::stylistic.
pub func css_font_feature_values_rule_stylistic(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_stylistic

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:31 Web::CSS::CSSFontFeatureValuesRule::swash.
pub func css_font_feature_values_rule_swash(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_swash

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:32 Web::CSS::CSSFontFeatureValuesRule::character_variant.
pub func css_font_feature_values_rule_character_variant(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_character_variant

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:33 Web::CSS::CSSFontFeatureValuesRule::styleset.
pub func css_font_feature_values_rule_styleset(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_styleset

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:34 Web::CSS::CSSFontFeatureValuesRule::historical_forms.
pub func css_font_feature_values_rule_historical_forms(this: CssFontFeatureValuesRule*) -> CssFontFeatureValuesMap*:
    return this.m_historical_forms

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.h:36 Web::CSS::CSSFontFeatureValuesRule::font_families.
pub func css_font_feature_values_rule_font_families(this: CssFontFeatureValuesRule*) -> ak.Vector[ak.FlyString]:
    return this.m_font_families

# mark: CSSFontFeatureValuesRule.cpp ============================================================

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:21 Web::CSS::CSSFontFeatureValuesRule::create.
pub func css_font_feature_values_rule_create(realm: Realm*, font_families: ak.Vector[ak.FlyString]) -> CssFontFeatureValuesRule*:
    return realm_create_css_font_feature_values_rule(realm, realm, font_families)

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:26 Web::CSS::CSSFontFeatureValuesRule::is_font_feature_value_type_at_keyword.
pub func css_font_feature_values_rule_is_font_feature_value_type_at_keyword(keyword: ak.FlyString) -> bool:
    return (ak.fly_string_eq_string_view(&keyword, ak.sv("stylistic")) or ak.fly_string_eq_string_view(&keyword, ak.sv("historical-forms")) or ak.fly_string_eq_string_view(&keyword, ak.sv("styleset")) or ak.fly_string_eq_string_view(&keyword, ak.sv("character-variant")) or ak.fly_string_eq_string_view(&keyword, ak.sv("swash")) or ak.fly_string_eq_string_view(&keyword, ak.sv("ornaments")) or ak.fly_string_eq_string_view(&keyword, ak.sv("annotation")))

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:31 Web::CSS::CSSFontFeatureValuesRule::CSSFontFeatureValuesRule.
pub func css_font_feature_values_rule_construct(this: CssFontFeatureValuesRule*, realm: Realm*, font_families: ak.Vector[ak.FlyString]):
    css_rule_construct(this.css_rule(), realm, CssRuleType.font_feature_values)
    this.m_font_families = font_families
    this.m_annotation = realm_create_css_font_feature_values_map(realm, realm, 1, this)
    this.m_ornaments = realm_create_css_font_feature_values_map(realm, realm, 1, this)
    this.m_stylistic = realm_create_css_font_feature_values_map(realm, realm, 1, this)
    this.m_swash = realm_create_css_font_feature_values_map(realm, realm, 1, this)
    this.m_character_variant = realm_create_css_font_feature_values_map(realm, realm, 2, this)
    this.m_styleset = realm_create_css_font_feature_values_map(realm, realm, ak.usize_max, this)
    this.m_historical_forms = realm_create_css_font_feature_values_map(realm, realm, 1, this)

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:44 Web::CSS::CSSFontFeatureValuesRule::font_family.
pub func css_font_feature_values_rule_font_family(this: CssFontFeatureValuesRule*) -> ak.FlyString:
    var builder = ak.string_builder_new()

    for family in ak.vector_span(&this.m_font_families):
        if ak.string_builder_length(&builder) > 0:
            ak.string_builder_append(&builder, ", ")

        let code_points = ak.fly_string_code_points(&family)
        if ak.utf8_view_contains_any_of(&code_points, web_infra.ascii_whitespace_code_points):
            css_syntax.serialize_a_string_string_builder(&builder, ak.fly_string_bytes_as_string_view(&family))
        else:
            css_syntax.serialize_an_identifier_string_builder(&builder, ak.fly_string_bytes_as_string_view(&family))

    return ak.fly_string_from_string(ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string"))

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:61 Web::CSS::CSSFontFeatureValuesRule::set_font_family.
pub func css_font_feature_values_rule_set_font_family(this: CssFontFeatureValuesRule*, value: ak.FlyString):
    var family_names: ak.Vector[ak.FlyString]

    let view = ak.fly_string_bytes_as_string_view(&value)
    let parts = ak.string_view_split_view_u8(&view, ',')
    for family_name in ak.vector_span_const(&parts):
        let trimmed = ak.string_view_trim_whitespace(&family_name)
        ak.vector_append_t(&family_names, ak.fly_string_from_utf8(trimmed) else trap("MUST: FlyString::from_utf8"))

    this.m_font_families = family_names

## serialized()'s serialize_font_feature_values_map lambda (captures: the builder).
func css_serialize_font_feature_values_map(builder: ak.StringBuilder*, map: CssFontFeatureValuesMap*, at_rule_name: str):
    var entries = css_font_feature_values_map_to_ordered_hash_map(map)
    if ak.ordered_hash_map_is_empty(&entries):
        return
    dump_appendff(builder, "  @{} {{", [ak.arg_str(at_rule_name)])

    for entry in ak.ordered_hash_map_begin(&entries):
        ak.string_builder_append_u8(builder, ' ')
        css_syntax.serialize_an_identifier_string_builder(builder, ak.fly_string_bytes_as_string_view(&entry.key))
        ak.string_builder_append_u8(builder, ':')

        for i in 0..<ak.vector_size(&entry.value):
            dump_appendff(builder, " {}", [ak.arg_u64((u64)*ak.vector_at_const(&entry.value, i))])

        ak.string_builder_append(builder, ";")
    ak.string_builder_append(builder, " }")

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:71 Web::CSS::CSSFontFeatureValuesRule::serialized (override).
pub func css_font_feature_values_rule_serialized_impl(base: CssRule*) -> ak.String:
    let this = (CssFontFeatureValuesRule*)base
    var builder = ak.string_builder_new()

    let font_family = css_font_feature_values_rule_font_family(this)
    dump_appendff(&builder, "@font-feature-values {} {{", [css_arg_fly_string(&font_family)])

    css_serialize_font_feature_values_map(&builder, this.m_annotation, "annotation")
    css_serialize_font_feature_values_map(&builder, this.m_ornaments, "ornaments")
    css_serialize_font_feature_values_map(&builder, this.m_stylistic, "stylistic")
    css_serialize_font_feature_values_map(&builder, this.m_swash, "swash")
    css_serialize_font_feature_values_map(&builder, this.m_character_variant, "character-variant")
    css_serialize_font_feature_values_map(&builder, this.m_styleset, "styleset")
    css_serialize_font_feature_values_map(&builder, this.m_historical_forms, "historical-forms")
    ak.string_builder_append(&builder, " }")

    return ak.string_builder_to_string_without_validation(&builder)

## Add the entries of `map` to `result` as keys of `type_` (one loop of to_hash_map).
func css_font_feature_values_add_entries(result: ak.HashMap[CssFontFeatureValueKey, ak.Vector[u32], CssFontFeatureValueKeyTraits]*, type_: CssFontFeatureValueType, map: CssFontFeatureValuesMap*):
    var entries = css_font_feature_values_map_to_ordered_hash_map(map)
    for entry in ak.ordered_hash_map_begin(&entries):
        _ = ak.hash_map_set(result, CssFontFeatureValueKey(type_ = type_, name = entry.key), entry.value)

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:107 Web::CSS::CSSFontFeatureValuesRule::to_hash_map.
pub func css_font_feature_values_rule_to_hash_map(this: CssFontFeatureValuesRule*) -> ak.HashMap[CssFontFeatureValueKey, ak.Vector[u32], CssFontFeatureValueKeyTraits]:
    var map: ak.HashMap[CssFontFeatureValueKey, ak.Vector[u32], CssFontFeatureValueKeyTraits]

    css_font_feature_values_add_entries(&map, CssFontFeatureValueType.annotation, this.m_annotation)
    css_font_feature_values_add_entries(&map, CssFontFeatureValueType.ornaments, this.m_ornaments)
    css_font_feature_values_add_entries(&map, CssFontFeatureValueType.stylistic, this.m_stylistic)
    css_font_feature_values_add_entries(&map, CssFontFeatureValueType.swash, this.m_swash)
    css_font_feature_values_add_entries(&map, CssFontFeatureValueType.character_variant, this.m_character_variant)
    css_font_feature_values_add_entries(&map, CssFontFeatureValueType.styleset, this.m_styleset)

    # NB: We don't include historical-forms since it can't be referenced - it seems like it's inclusion in the syntax
    #     for @font-feature-values was a mistake and isn't supported by Chrome or Firefox. See
    #     https://github.com/w3c/csswg-drafts/issues/9926#issuecomment-2017241274

    return map

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:136 Web::CSS::CSSFontFeatureValuesRule::clear_caches (override).
pub func css_font_feature_values_rule_clear_caches_impl(base: CssRule*):
    let this = (CssFontFeatureValuesRule*)base
    css_rule_clear_caches_impl(base)
    let parent_style_sheet = css_rule_parent_style_sheet(base) else return

    let document = css_css_style_sheet_owning_document(parent_style_sheet) else return

    for family in ak.vector_span(&this.m_font_families):
        css_font_computer_clear_computed_font_cache(dom_document_font_computer(document), family)
        css_font_computer_clear_font_feature_values_cache(dom_document_font_computer(document), family)

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:155 Web::CSS::CSSFontFeatureValuesRule::initialize (override).
pub func css_font_feature_values_rule_initialize_impl(base: JsCell*, realm: Realm*):
    web_set_prototype_for_interface(base, realm, BindInterfaceName.css_font_feature_values_rule)
    js_cell_initialize_impl(base, realm)

## Ported from Libraries/LibWeb/CSS/CSSFontFeatureValuesRule.cpp:161 Web::CSS::CSSFontFeatureValuesRule::visit_edges (override).
pub func css_font_feature_values_rule_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (CssFontFeatureValuesRule*)base
    css_rule_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t_2(visitor, this.m_annotation)
    gc.cell_visitor_visit_t_2(visitor, this.m_ornaments)
    gc.cell_visitor_visit_t_2(visitor, this.m_stylistic)
    gc.cell_visitor_visit_t_2(visitor, this.m_swash)
    gc.cell_visitor_visit_t_2(visitor, this.m_character_variant)
    gc.cell_visitor_visit_t_2(visitor, this.m_styleset)
    gc.cell_visitor_visit_t_2(visitor, this.m_historical_forms)