Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / layout / grid_formatting_context_7.lucb

#==============================================================================================
#
#   grid_formatting_context_7 - Layout::GridFormattingContext: the items' size contributions
#                               and automatic minimum sizes
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/GridFormattingContext.cpp (lines 2464-2850): the grid container's
#       maximum size, the items' min- and max-content sizes and contributions, their
#       containing block (the sum of the tracks and gaps they span), the limited contributions
#       of items under fixed max track sizing functions
#       (https://drafts.csswg.org/css-grid-2/#algo-spanning-items), the specified,
#       transferred and content size suggestions, the content-based minimum size
#       (https://www.w3.org/TR/css-grid-1/#content-based-minimum-size), the automatic minimum
#       size, the minimum contribution, and the static position rectangle of an absolutely
#       positioned child.
#
#       Copyright (c) 2023-2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       Copyright (c) 2022-2023, Martin Falisse <mfalisse@outlook.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: The grid container's maximum size =======================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2464 Web::Layout::GridFormattingContext::should_treat_grid_container_maximum_size_as_none.
func layout_grid_formatting_context_should_treat_grid_container_maximum_size_as_none(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> bool:
    let available_space = layout_grid_formatting_context_available_space(this)
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_should_treat_max_width_as_none(this.layout_formatting_context(), layout_grid_formatting_context_grid_container(this), available_space.width)
    return layout_formatting_context_should_treat_max_height_as_none(this.layout_formatting_context(), layout_grid_formatting_context_grid_container(this), available_space.height)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2471 Web::Layout::GridFormattingContext::calculate_grid_container_maximum_size.
func layout_grid_formatting_context_calculate_grid_container_maximum_size(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    let grid_container = layout_grid_formatting_context_grid_container(this)
    let computed_values = layout_box_computed(grid_container)
    let available_space = layout_grid_formatting_context_available_space(this)
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_calculate_inner_width(this.layout_formatting_context(), grid_container, available_space.width, css_computed_values_max_width(computed_values))
    return layout_formatting_context_calculate_inner_height(this.layout_formatting_context(), grid_container, available_space, css_computed_values_max_height(computed_values))

# mark: Content sizes and contributions =========================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2479 Web::Layout::GridFormattingContext::calculate_min_content_size.
func layout_grid_formatting_context_calculate_min_content_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_calculate_min_content_width(this.layout_formatting_context(), item.box)
    let item_available_space = layout_grid_item_available_space(item)
    return layout_formatting_context_calculate_min_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&item_available_space.width))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2487 Web::Layout::GridFormattingContext::calculate_max_content_size
## (nothing calls it, in C++ either; public so the module checks without an unused-function warning).
pub func layout_grid_formatting_context_calculate_max_content_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_calculate_max_content_width(this.layout_formatting_context(), item.box)
    let item_available_space = layout_grid_item_available_space(item)
    return layout_formatting_context_calculate_max_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&item_available_space.width))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2495 Web::Layout::GridFormattingContext::containing_block_size_for_item.
func layout_grid_formatting_context_containing_block_size_for_item(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    var containing_block_size = layout_zero_px()
    for track in layout_grid_formatting_context_for_each_spanned_track_by_item_const(this, item, dimension):
        containing_block_size = containing_block_size.add(track.base_size)
    return containing_block_size

## `item.maximum_size(dimension)` in pixels when it is a length, else CSSPixels::max() (the contributions' upper bound).
func layout_grid_formatting_context_maximum_size_px(item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    var maximum_size = gfx.css_pixels_max()
    let css_maximum_size = layout_grid_item_maximum_size(item, dimension)
    if css_size_is_length(&css_maximum_size):
        let length = css_size_length(&css_maximum_size)
        maximum_size = css_length_to_px_layout_node(&length, item.box.layout_node())
    return maximum_size

## The `should_treat_preferred_size_as_auto` lambda of the contributions.
func layout_grid_formatting_context_should_treat_preferred_size_as_auto(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension, available_space_for_item: LayoutAvailableSpace) -> bool:
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_should_treat_width_as_auto(this.layout_formatting_context(), item.box, available_space_for_item)
    return layout_formatting_context_should_treat_height_as_auto(this.layout_formatting_context(), item.box, available_space_for_item)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2504 Web::Layout::GridFormattingContext::calculate_min_content_contribution.
func layout_grid_formatting_context_calculate_min_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    let base = this.layout_formatting_context()
    let available_space_for_item = layout_grid_item_available_space(item)

    let should_treat_preferred_size_as_auto = layout_grid_formatting_context_should_treat_preferred_size_as_auto(this, item, dimension, available_space_for_item)

    let maximum_size = layout_grid_formatting_context_maximum_size_px(item, dimension)

    if should_treat_preferred_size_as_auto:
        var min_content_size: gfx.CssPixels
        # NOTE: Not defined in spec, but matches other browsers: a scroll container's min-content
        #       width contribution is 0 because its content can overflow and scroll horizontally.
        #       This does NOT apply to the row dimension — scroll containers must still contribute
        #       their content height, otherwise grids with height:min-content collapse rows to 0.
        if dimension == LayoutGridDimension.column and layout_node_with_style_is_scroll_container(item.box.layout_node_with_style()):
            min_content_size = layout_zero_px()
        else:
            min_content_size = layout_grid_formatting_context_calculate_min_content_size(this, item, dimension)
        let result = layout_grid_item_add_margin_box_sizes(item, min_content_size, dimension)
        return ak.min(result, maximum_size)

    let preferred_size = layout_grid_item_preferred_size(item, dimension)
    let available_space = layout_grid_formatting_context_available_space(this)
    if dimension == LayoutGridDimension.column:
        let width = layout_formatting_context_calculate_inner_width(base, item.box, available_space.width, preferred_size)
        return ak.min(layout_grid_item_add_margin_box_sizes(item, width, dimension), maximum_size)
    let height = layout_formatting_context_calculate_inner_height(base, item.box, available_space, preferred_size)
    return ak.min(layout_grid_item_add_margin_box_sizes(item, height, dimension), maximum_size)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2543 Web::Layout::GridFormattingContext::calculate_max_content_contribution.
func layout_grid_formatting_context_calculate_max_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    let base = this.layout_formatting_context()
    let available_space_for_item = layout_grid_item_available_space(item)

    let should_treat_preferred_size_as_auto = layout_grid_formatting_context_should_treat_preferred_size_as_auto(this, item, dimension, available_space_for_item)

    let maximum_size = layout_grid_formatting_context_maximum_size_px(item, dimension)

    let preferred_size = layout_grid_item_preferred_size(item, dimension)
    if should_treat_preferred_size_as_auto or css_size_is_fit_content(&preferred_size):
        let fit_content_size = layout_formatting_context_calculate_fit_content_width(base, item.box, available_space_for_item) if dimension == LayoutGridDimension.column else layout_formatting_context_calculate_fit_content_height(base, item.box, available_space_for_item)
        let result = layout_grid_item_add_margin_box_sizes(item, fit_content_size, dimension)
        return ak.min(result, maximum_size)

    # The `resolve_size` lambda.
    var resolved_size: gfx.CssPixels
    let available_width = layout_available_size_make_definite(layout_clamp_to_max_dimension_value(layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.column)))
    if dimension == LayoutGridDimension.row:
        let available_height = layout_available_size_make_definite(layout_clamp_to_max_dimension_value(layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.row)))
        let item_available_space = LayoutAvailableSpace(width = available_width, height = available_height)
        resolved_size = layout_formatting_context_calculate_inner_height(base, item.box, item_available_space, preferred_size)
    else:
        resolved_size = layout_formatting_context_calculate_inner_width(base, item.box, available_width, preferred_size)

    let result = layout_grid_item_add_margin_box_sizes(item, resolved_size, dimension)
    return ak.min(result, maximum_size)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2579 Web::Layout::GridFormattingContext::calculate_fixed_max_track_size_limit.
func layout_grid_formatting_context_calculate_fixed_max_track_size_limit(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels?:
    # https://drafts.csswg.org/css-grid-2/#algo-spanning-items
    # For an item spanning multiple tracks, the upper limit used to calculate its limited min-/max-content
    # contribution is the sum of the fixed max track sizing functions of any tracks it spans, and is applied
    # if it only spans such tracks.
    #
    # https://drafts.csswg.org/css-grid-2#algo-terms
    # In all cases, treat auto and fit-content() as max-content, except where specified otherwise for fit-content().
    let available_size = layout_grid_formatting_context_available_size(this, dimension)
    let grid_container = layout_grid_formatting_context_grid_container(this).layout_node()

    var result = layout_zero_px()
    var saw_track = false
    var has_limit = true
    for track in layout_grid_formatting_context_for_each_spanned_track_by_item_const(this, item, dimension):
        # (The C++ callback returns early; the walk itself goes on.)
        if not has_limit:
            continue

        saw_track = true
        let max_track_sizing_function = track.max_track_sizing_function

        if css_grid_size_is_fixed(&max_track_sizing_function, available_size):
            let max_track_size = css_grid_size_css_size(&max_track_sizing_function)
            result = result.add(css_size_to_px(&max_track_size, grid_container, layout_available_size_to_px_or_zero(&available_size)))
            continue

        if css_grid_size_is_fit_content(&max_track_sizing_function):
            let max_track_size = css_grid_size_css_size(&max_track_sizing_function)
            if let fit_content_available_space = css_size_fit_content_available_space(&max_track_size):
                if not css_percentage_or_contains_percentage(&fit_content_available_space.percentage_or) or layout_available_size_is_definite(&available_size):
                    result = result.add(css_size_to_px(&max_track_size, grid_container, layout_available_size_to_px_or_zero(&available_size)))
                    continue

        has_limit = false

    if not has_limit:
        return none
    if not saw_track:
        return none
    return result

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2626 Web::Layout::GridFormattingContext::calculate_limited_min_content_contribution.
func layout_grid_formatting_context_calculate_limited_min_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    # The limited min-content contribution of an item is its min-content contribution,
    # limited by the max track sizing function (which could be the argument to a fit-content() track
    # sizing function) if that is fixed and ultimately floored by its minimum contribution.
    let min_content_contribution = layout_grid_formatting_context_calculate_min_content_contribution(this, item, dimension)
    let minimum_contribution = layout_grid_formatting_context_calculate_minimum_contribution(this, item, dimension)
    if min_content_contribution.lt(minimum_contribution):
        return minimum_contribution

    if let fixed_max_track_size_limit = layout_grid_formatting_context_calculate_fixed_max_track_size_limit(this, item, dimension):
        return ak.max(ak.min(min_content_contribution, fixed_max_track_size_limit), minimum_contribution)

    if not layout_grid_formatting_context_should_treat_grid_container_maximum_size_as_none(this, dimension):
        let max_size = layout_grid_formatting_context_calculate_grid_container_maximum_size(this, dimension)
        if min_content_contribution.gt(max_size):
            return max_size

    return min_content_contribution

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2648 Web::Layout::GridFormattingContext::calculate_limited_max_content_contribution.
func layout_grid_formatting_context_calculate_limited_max_content_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    # The limited max-content contribution of an item is its max-content contribution,
    # limited by the max track sizing function (which could be the argument to a fit-content() track
    # sizing function) if that is fixed and ultimately floored by its minimum contribution.
    let max_content_contribution = layout_grid_formatting_context_calculate_max_content_contribution(this, item, dimension)
    let minimum_contribution = layout_grid_formatting_context_calculate_minimum_contribution(this, item, dimension)
    if max_content_contribution.lt(minimum_contribution):
        return minimum_contribution

    if let fixed_max_track_size_limit = layout_grid_formatting_context_calculate_fixed_max_track_size_limit(this, item, dimension):
        return ak.max(ak.min(max_content_contribution, fixed_max_track_size_limit), minimum_contribution)

    if not layout_grid_formatting_context_should_treat_grid_container_maximum_size_as_none(this, dimension):
        let max_size = layout_grid_formatting_context_calculate_grid_container_maximum_size(this, dimension)
        if max_content_contribution.gt(max_size):
            return max_size

    return max_content_contribution

# mark: Minimum sizes ===========================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2670 Web::Layout::GridFormattingContext::content_size_suggestion.
func layout_grid_formatting_context_content_size_suggestion(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    # The content size suggestion is the min-content size in the relevant axis
    # FIXME: clamped, if it has a preferred aspect ratio, by any definite opposite-axis minimum and maximum sizes
    # converted through the aspect ratio.
    return layout_grid_formatting_context_calculate_min_content_size(this, item, dimension)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2678 Web::Layout::GridFormattingContext::specified_size_suggestion.
func layout_grid_formatting_context_specified_size_suggestion(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels?:
    # https://www.w3.org/TR/css-grid-1/#specified-size-suggestion
    # If the item’s preferred size in the relevant axis is definite, then the specified size suggestion is that size.
    # It is otherwise undefined.
    let has_definite_preferred_size = layout_state_used_values_has_definite_width(item.used_values) if dimension == LayoutGridDimension.column else layout_state_used_values_has_definite_height(item.used_values)
    if has_definite_preferred_size:
        # FIXME: consider margins, padding and borders because it is outer size.
        let containing_block_size = layout_grid_formatting_context_containing_block_size_for_item(this, item, dimension)
        let preferred_size = layout_grid_item_preferred_size(item, dimension)
        return css_size_to_px(&preferred_size, item.box.layout_node(), containing_block_size)

    return none

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2693 Web::Layout::GridFormattingContext::transferred_size_suggestion.
func layout_grid_formatting_context_transferred_size_suggestion(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels?:
    _ = this
    # https://www.w3.org/TR/css-grid-2/#transferred-size-suggestion
    # If the item has a preferred aspect ratio and its preferred size in the opposite axis is definite, then the transferred
    # size suggestion is that size (clamped by the opposite-axis minimum and maximum sizes if they are definite), converted
    # through the aspect ratio. It is otherwise undefined.
    let preferred_aspect_ratio = layout_box_preferred_aspect_ratio(item.box) else return none

    let preferred_size_in_opposite_axis = layout_grid_item_preferred_size(item, LayoutGridDimension.row if dimension == LayoutGridDimension.column else LayoutGridDimension.column)
    if css_size_is_length(&preferred_size_in_opposite_axis):
        let length = css_size_length(&preferred_size_in_opposite_axis)
        let opposite_axis_size = css_length_to_px_layout_node(&length, item.box.layout_node())
        # FIXME: Clamp by opposite-axis minimum and maximum sizes if they are definite
        return opposite_axis_size.mul_fraction(preferred_aspect_ratio)

    return none

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2713 Web::Layout::GridFormattingContext::content_based_minimum_size.
func layout_grid_formatting_context_content_based_minimum_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    # https://www.w3.org/TR/css-grid-1/#content-based-minimum-size

    var result = layout_zero_px()
    # The content-based minimum size for a grid item in a given dimension is its specified size suggestion if it exists,
    if let specified_size_suggestion = layout_grid_formatting_context_specified_size_suggestion(this, item, dimension):
        result = specified_size_suggestion
    # otherwise its transferred size suggestion if that exists,
    elif let transferred_size_suggestion = layout_grid_formatting_context_transferred_size_suggestion(this, item, dimension):
        result = transferred_size_suggestion
    # else its content size suggestion.
    else:
        result = layout_grid_formatting_context_content_size_suggestion(this, item, dimension)

    # However, if in a given dimension the grid item spans only grid tracks that have a fixed max track sizing function, then
    # its specified size suggestion and content size suggestion in that dimension (and its input from this dimension to the
    # transferred size suggestion in the opposite dimension) are further clamped to less than or equal to the stretch fit into
    # the grid area’s maximum size in that dimension, as represented by the sum of those grid tracks’ max track sizing functions
    # plus any intervening fixed gutters.
    # FIXME: Account for intervening fixed gutters.
    let tracks = layout_grid_formatting_context_tracks(this, dimension)
    let available_size = layout_grid_formatting_context_available_size(this, dimension)
    let available_width = layout_grid_formatting_context_available_space(this).width
    let item_track_index = layout_grid_item_raw_position(item, dimension)
    let item_track_span = layout_grid_item_span(item, dimension)
    var spans_only_tracks_with_limited_max_track_sizing_function = true
    var sum_of_max_sizing_functions = layout_zero_px()
    for index in 0..<item_track_span:
        # `item_track_index + index`: int + size_t.
        let track = ak.vector_at(tracks, (usize)(i64)item_track_index +% index)
        if not css_grid_size_is_fixed(&track.max_track_sizing_function, available_size):
            spans_only_tracks_with_limited_max_track_sizing_function = false
            break
        let max_css_size = css_grid_size_css_size(&track.max_track_sizing_function)
        sum_of_max_sizing_functions = sum_of_max_sizing_functions.add(css_size_to_px(&max_css_size, item.box.layout_node(), layout_available_size_to_px_or_zero(&available_width)))
    if spans_only_tracks_with_limited_max_track_sizing_function:
        result = ak.min(result, sum_of_max_sizing_functions)

    # In all cases, the size suggestion is additionally clamped by the maximum size in the affected axis, if it’s definite.
    let maximum_size = layout_grid_item_maximum_size(item, dimension)
    if css_size_is_length(&maximum_size):
        let length = css_size_length(&maximum_size)
        let maximum_size_px = css_length_to_px_layout_node(&length, item.box.layout_node())
        result = ak.min(result, maximum_size_px)

    # If the item is a compressible replaced element, and has a definite preferred size or maximum size in the relevant axis,
    # the size suggestion is capped by those sizes; for this purpose, any indefinite percentages in these sizes are resolved
    # against zero (and considered definite).
    # FIXME: "compressible replaced element" includes more elements than is_replaced_box().
    let preferred_size = layout_grid_item_preferred_size(item, dimension)
    if layout_node_is_replaced_box(item.box.layout_node()) and (css_size_is_percentage(&preferred_size) or css_size_is_percentage(&maximum_size)):
        # NOTE: Implements "for this purpose, any indefinite percentages in these sizes are resolved
        #       against zero (and considered definite)." part.
        result = layout_zero_px()

    return result

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2776 Web::Layout::GridFormattingContext::automatic_minimum_size.
func layout_grid_formatting_context_automatic_minimum_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    # To provide a more reasonable default minimum size for grid items, the used value of its automatic minimum size
    # in a given axis is the content-based minimum size if all of the following are true:
    # - it is not a scroll container
    # - it spans at least one track in that axis whose min track sizing function is auto
    # - if it spans more than one track in that axis, none of those tracks are flexible
    let tracks = layout_grid_formatting_context_tracks(this, dimension)
    let item_track_index = layout_grid_item_raw_position(item, dimension)
    let item_track_span = layout_grid_item_span(item, dimension)

    let available_size = layout_grid_formatting_context_available_size(this, dimension)

    var spans_auto_tracks = false
    var spans_flexible_tracks = false
    for index in 0..<item_track_span:
        let track = ak.vector_at(tracks, (usize)(i64)item_track_index +% index)
        if css_grid_size_is_flexible_length(&track.max_track_sizing_function):
            spans_flexible_tracks = true
        if css_grid_size_is_auto(&track.min_track_sizing_function, available_size):
            spans_auto_tracks = true
    if spans_auto_tracks and not layout_node_with_style_is_scroll_container(item.box.layout_node_with_style()) and (item_track_span == 1 or not spans_flexible_tracks):
        return layout_grid_formatting_context_content_based_minimum_size(this, item, dimension)

    # Otherwise, the automatic minimum size is zero, as usual.
    return layout_zero_px()

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2806 Web::Layout::GridFormattingContext::calculate_minimum_contribution.
func layout_grid_formatting_context_calculate_minimum_contribution(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension) -> gfx.CssPixels:
    # The minimum contribution of an item is the smallest outer size it can have.
    # Specifically, if the item’s computed preferred size behaves as auto or depends on the size of its
    # containing block in the relevant axis, its minimum contribution is the outer size that would
    # result from assuming the item’s used minimum size as its preferred size; else the item’s minimum
    # contribution is its min-content contribution. Because the minimum contribution often depends on
    # the size of the item’s content, it is considered a type of intrinsic size contribution.

    let base = this.layout_formatting_context()
    # (The C++ copies the preferred size into a local it never reads.)
    let should_treat_preferred_size_as_auto = layout_grid_formatting_context_should_treat_preferred_size_as_auto(this, item, dimension, layout_grid_item_available_space(item))

    if should_treat_preferred_size_as_auto:
        let minimum_size = layout_grid_item_minimum_size(item, dimension)
        if css_size_is_auto(&minimum_size):
            return layout_grid_item_add_margin_box_sizes(item, layout_grid_formatting_context_automatic_minimum_size(this, item, dimension), dimension)
        if css_size_is_min_content(&minimum_size):
            return layout_grid_formatting_context_calculate_min_content_contribution(this, item, dimension)
        if css_size_is_max_content(&minimum_size):
            return layout_grid_formatting_context_calculate_max_content_contribution(this, item, dimension)
        var inner_minimum_size: gfx.CssPixels
        let item_available_space = layout_grid_item_available_space(item)
        if dimension == LayoutGridDimension.column:
            inner_minimum_size = layout_formatting_context_calculate_inner_width(base, item.box, item_available_space.width, minimum_size)
        else:
            inner_minimum_size = layout_formatting_context_calculate_inner_height(base, item.box, item_available_space, minimum_size)
        return layout_grid_item_add_margin_box_sizes(item, inner_minimum_size, dimension)

    return layout_grid_formatting_context_calculate_min_content_contribution(this, item, dimension)

# mark: Static position =========================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:2841 Web::Layout::GridFormattingContext::calculate_static_position_rect.
pub func layout_grid_formatting_context_calculate_static_position_rect(this: LayoutGridFormattingContext*, box: LayoutBox*) -> LayoutStaticPositionRect:
    # Result of this function is only used when containing block is not a grid container.
    # If the containing block is a grid container then static position is a grid area rect and
    # layout_absolutely_positioned_element() defined for GFC knows how to handle this case.
    var static_position = LayoutStaticPositionRect(rect = gfx.CssPixelRect(), horizontal_alignment = LayoutStaticPositionRectAlignment.start, vertical_alignment = LayoutStaticPositionRectAlignment.start)
    let box_state = layout_state_get(this.formatting_context.m_state, box.layout_node_with_style())
    static_position.rect = gfx.CssPixelRect(m_location = gfx.CssPixelPoint(m_x = layout_zero_px(), m_y = layout_zero_px()), m_size = gfx.CssPixelSize(m_width = layout_state_used_values_content_width(box_state), m_height = layout_state_used_values_content_height(box_state)))
    return static_position