dataface 0.3.2.dev22__py3-none-any.whl → 0.3.2.dev111__py3-none-any.whl

dataface/core/render/chart/features/endpoint_labels.py

@@ -18,6 +18,7 @@ from dataface.core.render.chart.emitters._cartesian import (
     last_nonnull_value_per_series,
     sorted_series_by_stack_order,
 )
+from dataface.core.utils import numeric_column_values, stacked_x_domain_order
 
 # Cascade geometry constants.
 # 1.3: bounding rects kiss at 1.0× but descenders on ascenders touch; 1.3
@@ -124,7 +125,8 @@ def _y_domain(
     back to raw data range when no explicit domain is authored.
     """
     if axis_y.scale is not None:
-        domain = axis_y.scale.domain
+        _ay_cont_el = axis_y.scale.continuous
+        domain = _ay_cont_el.domain if _ay_cont_el is not None else None
         if isinstance(domain, list) and len(domain) == 2:
             try:
                 lo, hi = float(domain[0]), float(domain[1])
@@ -191,8 +193,8 @@ def _wide_y_domain(
     axis_y: ResolvedAxisStyle,
 ) -> tuple[float, float]:
     """Return the shared measure extent for an area with folded wide measures."""
-    if axis_y.scale is not None:
-        domain = axis_y.scale.domain
+    if axis_y.scale is not None and axis_y.scale.continuous is not None:
+        domain = axis_y.scale.continuous.domain
         if isinstance(domain, list) and len(domain) == 2:
             try:
                 lo, hi = float(domain[0]), float(domain[1])
@@ -263,6 +265,30 @@ def _cascade_gap(
     return label_gap_px * (y_range / (height * _PLOT_AREA_FRACTION))
 
 
+def _refuse_unorderable_sort(
+    chart_id: str, data: list[dict[str, Any]], sort: Any
+) -> None:
+    """Refuse a `sort:` whose column carries no numbers to total.
+
+    ``stacked_x_domain_order`` reproduces Vega-Lite's domain order by summing
+    the sort field per category, which is what VL's default ``sum`` op does.
+    On a non-numeric column VL concatenates the strings instead — an order this
+    cannot reproduce — so the rail would anchor on a row VL does not draw on
+    top. Resolve steers the default away from this shape; an explicit opt-in
+    lands here and gets told why.
+    """
+    if sort is None or numeric_column_values(data, sort.by):
+        return
+    raise ChartDataError(
+        f"chart.sort by {sort.by!r} cannot be combined with stacked bar "
+        "endpoint labels — the label rail reproduces Vega-Lite's domain order "
+        "by totalling that column per category, and it carries no numeric "
+        "values. To fix: sort by a measure, or set "
+        "endpoint_labels.visible: false on this chart.",
+        chart_id,
+    )
+
+
 def _stacked_midpoints(
     data: list[dict[str, Any]],
     x_field: str,
@@ -270,6 +296,8 @@ def _stacked_midpoints(
     series_field: str,
     stack_mode: str,
     max_column_total: float,
+    sort_by: str,
+    descending: bool,
     stack_order: str | None = None,
 ) -> list[tuple[str, float]]:
     """Compute cumulative segment midpoints for vertical stacked bars or areas.
@@ -299,14 +327,8 @@ def _stacked_midpoints(
     ``_stacked_y_domain`` computes for this data when ``stack_mode ==
     "center"``.
     """
-    # Largest x value = last bar column.
-    last_x = None
-    for row in data:
-        v = row.get(x_field)
-        if v is None:
-            continue
-        if last_x is None or v > last_x:
-            last_x = v
+    domain = stacked_x_domain_order(data, x_field, sort_by, descending)
+    last_x = domain[-1] if domain else None
 
     values_at_last: dict[str, float] = {}
     for row in data:
@@ -405,11 +427,14 @@ def _cumulative_midpoints(
     x_field: str,
     y_field: str,
     series_field: str,
+    sort_by: str,
+    descending: bool,
     stack_mode: str = "zero",
 ) -> list[tuple[str, float]]:
     """Return (series, x_midpoint) for the top categorical row (un-nudged).
 
-    The "top row" is the alphabetically first x-domain value.  Midpoint is the
+    The "top row" is the first value of the rendered x domain — alphabetically
+    first, or first under an authored ``sort:``.  Midpoint is the
     cumulative x at the series segment's centre, ordered largest-global-sum first
     (matching V1's _apply_stacked_bar_z_order default/"value" ordering, which VL
     enforces via encoding.order + joinaggregate).  Sufficient for correct
@@ -418,8 +443,7 @@ def _cumulative_midpoints(
     For ``stack_mode == "normalize"``, midpoints are divided by the top-row total
     so they land on the 0..1 scale that VL renders for normalize stacks.
     """
-    # Collect all x-domain values to find the alphabetical first.
-    x_values = sorted({row[x_field] for row in data if row.get(x_field) is not None})
+    x_values = stacked_x_domain_order(data, x_field, sort_by, descending)
     if not x_values:
         return []
     top_row_x = x_values[0]
@@ -517,10 +541,7 @@ class EndpointLabelFeature:
             # Top-row series rail only applies to stacked horizontals; grouped
             # bars sit side-by-side and form no stacks to label.
             return chart.stack not in (None, "none")
-        # Vertical stacked bar has no computed center-stack anchor (unlike
-        # area's streamgraph case below), so it still skips the feature
-        # rather than mislabeling a diverging domain.
-        return not (isinstance(chart, ResolvedBarChart) and chart.stack == "center")
+        return True
 
     def apply(
         self,
@@ -579,6 +600,7 @@ class EndpointLabelFeature:
             y_field = chart.y
             if not isinstance(y_field, str):
                 return spec
+            _refuse_unorderable_sort(chart.id, data, chart.sort)
             if chart.stack == "center":
                 raise ChartDataError(
                     "stack: 'center' is not supported for horizontal stacked bar "
@@ -586,13 +608,6 @@ class EndpointLabelFeature:
                     "axis, not the diverging (-Σ/2..+Σ/2) center-stack domain.",
                     chart.id,
                 )
-            if chart.sort is not None:
-                raise ChartDataError(
-                    "chart.sort cannot be combined with horizontal stacked bar "
-                    "endpoint labels — the label rail anchors at the "
-                    "alphabetical-first row, which chart.sort would move.",
-                    chart.id,
-                )
             if _has_negative_measure(data, y_field):
                 raise ChartDataError(
                     "negative values are not supported for horizontal stacked bar "
@@ -600,7 +615,13 @@ class EndpointLabelFeature:
                     chart.id,
                 )
             positions = _cumulative_midpoints(
-                data, x_field, y_field, series_field, stack_mode=chart.stack or "zero"
+                data,
+                x_field,
+                y_field,
+                series_field,
+                chart.sort.by if chart.sort else "",
+                bool(chart.sort and chart.sort.order == "desc"),
+                stack_mode=chart.stack or "zero",
             )
             # For normalize stacks the chart pane's x encoding must explicitly
             # pin [0, 1] so the shared vconcat x-scale propagates to the rail
@@ -645,12 +666,10 @@ class EndpointLabelFeature:
             ) and chart.stack not in (None, "none")
             if is_stacked:
                 assert isinstance(chart, (ResolvedBarChart, ResolvedAreaChart))
-                # Vertical bar's center-stack never reaches here — applies_to()
-                # still skips it. Area's center-stack (streamgraph) does reach
-                # here; its anchors use the same cumulative math offset by the
-                # center baseline (see _stacked_midpoints/_stacked_y_domain).
-                assert not (
-                    isinstance(chart, ResolvedBarChart) and chart.stack == "center"
+                _refuse_unorderable_sort(
+                    chart.id,
+                    data,
+                    chart.sort if isinstance(chart, ResolvedBarChart) else None,
                 )
                 if _has_negative_measure(data, y_field):
                     raise ChartDataError(
@@ -669,6 +688,8 @@ class EndpointLabelFeature:
                     if isinstance(chart, ResolvedBarChart)
                     else NATIVE_STACK_ORDER
                 )
+                # Area has no authored sort; only bar carries one.
+                _sort = chart.sort if isinstance(chart, ResolvedBarChart) else None
                 y_domain_min, y_domain_max = _stacked_y_domain(
                     data, x_field, y_field, stack_mode
                 )
@@ -679,6 +700,8 @@ class EndpointLabelFeature:
                     series_field,
                     stack_mode,
                     y_domain_max,
+                    _sort.by if _sort else "",
+                    bool(_sort and _sort.order == "desc"),
                     stack_order=stack_order,
                 )
                 # Pin the main pane's y domain so VL's shared hconcat y-scale

dataface/core/render/chart/features/mirror_axis.py

@@ -108,7 +108,7 @@ class MirrorAxisFeature:
         if isinstance(mirror, AxisMirrorStyle):
             if mirror.format is not None:
                 ghost_axis["format"] = mirror.format
-                # The primary may carry a labelExpr (style.axis_y.label.expr),
+                # The primary may carry a labelExpr (style.axis_y.labels.expr),
                 # which VL prefers over format — drop the inherited copy so the
                 # explicit per-edge format actually takes effect.
                 ghost_axis.pop("labelExpr", None)
@@ -140,7 +140,10 @@ class MirrorAxisFeature:
                         tuple(axis_y.tick_values), ghost_format
                     )
                 elif isinstance(chart.y, str):
-                    domain = axis_y.scale.domain if axis_y.scale is not None else None
+                    _ay_cont_m = (
+                        axis_y.scale.continuous if axis_y.scale is not None else None
+                    )
+                    domain = _ay_cont_m.domain if _ay_cont_m is not None else None
                     bounds = numeric_domain_bounds(domain)
                     values = numeric_values(chart_rows(chart, datasets), (chart.y,)) + (
                         list(bounds) if bounds is not None else []
@@ -148,14 +151,14 @@ class MirrorAxisFeature:
                     labels = estimated_quantitative_tick_labels(values, ghost_format)
             if labels:
                 tick_size = (
-                    axis_y.ticks.size
-                    if axis_y.ticks.size is not None
+                    axis_y.ticks.length
+                    if axis_y.ticks.length is not None
                     else DEFAULT_VL_TICK_SIZE
                 )
-                padding = measured_label_padding(labels, axis_y.label.font, tick_size)
+                padding = measured_label_padding(labels, axis_y.labels.font, tick_size)
                 label_limit = (
-                    axis_y.label.max_width
-                    if axis_y.label.max_width is not None
+                    axis_y.labels.max_width
+                    if axis_y.labels.max_width is not None
                     else DEFAULT_VL_LABEL_LIMIT
                 )
                 ghost_axis["labelPadding"] = cap_padding_to_label_limit(
@@ -163,12 +166,12 @@ class MirrorAxisFeature:
                 )
             else:
                 raise ChartDataError(
-                    f"axis_y.label.align: {ghost_align!r} cannot be "
+                    f"axis_y.labels.align: {ghost_align!r} cannot be "
                     "combined with axis_y.mirror — the alignment that keeps "
                     f"labels outside the plot on the {primary} edge draws the "
                     f"mirrored {opposite}-edge labels back across the axis "
                     "into the plot, and Dataface has no baked tick content to "
-                    "measure a safe labelPadding from. Omit label.align; each "
+                    "measure a safe labelPadding from. Omit labels.align; each "
                     "edge then uses Vega-Lite's safe per-orient default.",
                     chart_id=chart.id,
                 )

dataface/core/render/chart/features/value_labels.py

@@ -441,7 +441,7 @@ class ValueLabelFeature:
             y,
             is_horiz,
             is_stacked,
-            chart.style.background,
+            chart.background,
         )
         if text_layer is None:
             return

dataface/core/render/chart/kpi.py

@@ -18,7 +18,7 @@ import html
 from dataclasses import dataclass
 from typing import Any
 
-from dataface.core.compile.colors import sanitize_color
+from dataface.core.colors import sanitize_color
 from dataface.core.compile.config import get_chart_rendering
 from dataface.core.compile.format import resolve_format
 from dataface.core.compile.models.chart.authored import (
@@ -28,11 +28,11 @@ from dataface.core.compile.models.chart.authored import (
     match_predicate,
 )
 from dataface.core.compile.models.chart.resolved import (
+    FormatState,
     ResolvedKpiChart,
     ResolvedStyleChannel,
 )
 from dataface.core.compile.models.primitives import (
-    FormatConfig,
     SpacingValues,
     ToneLiteral,
 )
@@ -62,6 +62,7 @@ from dataface.core.render.chart.title_overflow import (
 )
 from dataface.core.render.format_utils import format_kpi_parts
 from dataface.core.render.utils import resolve_tone_color
+from dataface.core.utils import coerce_numeric_cell
 
 # Typographic ratios for KPI geometry. Tuned by eye against the playground
 # specimen.
@@ -214,87 +215,9 @@ def _resolve_value(raw: str, row: dict[str, Any], chart_id: str) -> tuple[Any, s
     )
 
 
-def _coerce_numeric_value(cell: Any) -> float | None:
-    """Coerce ``cell`` to a float or return None if it should be rendered as a string.
-
-    ``bool`` is treated as a string-class value even though it is technically
-    an ``int`` subclass — rendering ``True`` through the narrative-notation
-    pipeline as ``1.0`` would be magic behavior the author did not ask for.
-    """
-    if cell is None or isinstance(cell, bool):
-        return None
-    if isinstance(cell, (int, float)):
-        return float(cell)
-    try:
-        return float(cell)
-    except (ValueError, TypeError):
-        # String literals like "At risk" stay as strings.
-        return None
-
-
-# d3's first SI prefix ("k") engages at 1000. Below it, ".2s" doesn't compact —
-# it rounds to 2 significant figures on plain digits instead (131 -> "130"),
-# which drops information the author never asked to lose. Digit-integrity
-# rule: rounding is acceptable under SI compaction, never on plain digits —
-# so the default only compacts once compaction is real.
-_SI_COMPACT_THRESHOLD = 1000.0
-
-
-def _narrative_format_default(
-    format_input: str | FormatConfig | dict[str, Any] | None,
-    value: float | None,
-) -> str | FormatConfig | dict[str, Any] | None:
-    """Apply KPI's narrative defaults when the author did not pick them.
-
-    KPI is a hero number that the reader pauses on, so it defaults to the
-    narrative notation register (``1.5mn``) instead of the analytic register
-    (``1.5 M``) used on axis ticks and table cells. When neither spec nor
-    notation is authored, and ``value`` is large enough to actually compact
-    (``|value| >= 1000``), we also default to compact SI form (``".2s"``) so
-    narrative notation shows up — notation alone is a no-op against a non-SI
-    spec. Below that threshold there is nothing to compact, so the value
-    renders its exact digits (no spec at all — the render layer's raw
-    numeric fallback) rather than a misleadingly-rounded plain number.
-    """
-    compact_eligible = value is not None and abs(value) >= _SI_COMPACT_THRESHOLD
-    if format_input is None:
-        if compact_eligible:
-            return FormatConfig(spec=".2s", notation="narrative")
-        return None
-    if isinstance(format_input, FormatConfig):
-        spec = format_input.spec
-        notation = format_input.notation
-        updates: dict[str, Any] = {}
-        if notation is None:
-            updates["notation"] = "narrative"
-        if (
-            spec is None
-            and (notation is None or notation in ("narrative", "analytic"))
-            and compact_eligible
-        ):
-            updates["spec"] = ".2s"
-        return format_input.model_copy(update=updates) if updates else format_input
-    if isinstance(format_input, dict):
-        spec = format_input.get("spec")
-        notation = format_input.get("notation")
-        updated = dict(format_input)
-        if notation is None:
-            updated["notation"] = "narrative"
-        if (
-            spec is None
-            and (notation is None or notation in ("narrative", "analytic"))
-            and compact_eligible
-        ):
-            updated["spec"] = ".2s"
-        return updated
-    # Plain string spec (e.g. ",.0f"): respect the author's spec; just add
-    # narrative notation so any SI-form spec they used renders narratively.
-    return FormatConfig(spec=str(format_input), notation="narrative")
-
-
 def _format_value_parts(
     cell: Any,
-    format_input: str | FormatConfig | dict[str, Any] | None,
+    format_input: FormatState,
     formats: dict[str, Any] | None = None,
 ) -> tuple[str, str, str, bool]:
     """Format a KPI cell into ``(prefix, number_str, suffix, is_numeric)``.
@@ -302,7 +225,7 @@ def _format_value_parts(
     Non-numeric cells are returned as a string in ``number_str`` with empty
     affixes — used for status-style KPIs like ``"At risk"``.
     """
-    numeric = _coerce_numeric_value(cell)
+    numeric = coerce_numeric_cell(cell)
     if numeric is None:
         text = "" if cell is None else str(cell)
         return "", text, "", False
@@ -695,7 +618,7 @@ def _resolve_kpi_layout(
 
 def _resolve_kpi_colors(
     row: dict[str, Any],
-    main_format: str | FormatConfig | dict[str, Any] | None,
+    main_format: FormatState,
     kpi_config: KpiChartStyle,
     resolved_channels: dict[str, ResolvedStyleChannel],
     chart_background: str | None,
@@ -866,13 +789,11 @@ def _render_kpi_svg_core(
     raw_value = chart.value
     row = data[0]
     cell, _value_column = _resolve_value(raw_value, row, chart_id)
-    # Apply narrative-notation default to the top-level KPI block only —
-    # support-block format defaults to analytic (its register matches dense
-    # axis/table use rather than the hero number above it).
-    # KPI format lives at style.value.format and is cascade-resolved into kpi_config.
-    main_format = _narrative_format_default(
-        kpi_config.value.format, _coerce_numeric_value(cell)
-    )
+    # chart.format is the final headline format — resolve() already applied
+    # the narrative-notation and SI-compaction defaults against this row's
+    # value; render just consumes it (support-block format stays analytic,
+    # resolved separately in _resolve_support_row).
+    main_format = chart.format
     prefix, number_str, suffix, value_is_numeric = _format_value_parts(
         cell, main_format, formats
     )

dataface/core/render/chart/presentation.py

@@ -10,8 +10,6 @@ from __future__ import annotations
 import copy
 from typing import Any
 
-from dataface.core.compile.models.style.resolved import ResolvedChartsStyle
-
 # Internal field name for the calculate-transform output backing the href
 # click-interactivity encoding. Consumed by translate.py.
 _HREF_FIELD = "__df_href__"
@@ -32,7 +30,7 @@ def overlay_merge(base: dict[str, Any], overlay: dict[str, Any]) -> dict[str, An
 
 def apply_presentation_defaults(
     spec: dict[str, Any],
-    resolved_chart_style: ResolvedChartsStyle,
+    background: str,
     effective_vega_config: dict[str, Any],
 ) -> dict[str, Any]:
     """Apply compiled presentation defaults to an emitted Vega-Lite spec once.
@@ -53,15 +51,15 @@ def apply_presentation_defaults(
 
     result_spec["config"] = compiled
 
-    # Background cascade: resolved_chart_style.background carries the board-level
-    # background (cascaded in from ResolvedStyle at resolve time) or a
-    # chart-local explicit override. Skip for geo charts that keep a transparent
-    # spec root (projection present, no authored background).
+    # Background cascade: background is the chart's own effective background
+    # (chart-local style.<family>.background when authored, otherwise the
+    # board/face background), baked at resolve time. Skip for geo charts that
+    # keep a transparent spec root (projection present, no authored background).
     preserve_transparent_background = (
         result_spec.get("background") is None and "projection" in result_spec
     )
     if not preserve_transparent_background:
-        result_spec["background"] = resolved_chart_style.background
+        result_spec["background"] = background
 
     result_spec["config"] = overlay_merge(result_spec["config"], authored_config)
     return result_spec

dataface/core/render/chart/rendering.py

@@ -159,19 +159,10 @@ def render_layout_item(
         rendered = ""
         actual_height = height
         if item.type == "chart" and item.chart:
-            # Per-family padding: baked into layout_padding at resolve time.
-            # Falls back to board-level padding for charts resolved outside the
-            # full pipeline (e.g. unit tests).
-            from dataface.core.compile.style_cascade import effective_chart_padding
-
+            # Per-family padding: baked into layout_padding at construction time
+            # by every family resolver — the single source of truth.
             card_padding = float(resolved_style.board.card_padding)
-            chart_padding = (
-                item.chart.layout_padding
-                if item.chart.layout_padding is not None
-                else effective_chart_padding(
-                    resolved_style.charts, item.chart.chart_type
-                )
-            )
+            chart_padding = item.chart.layout_padding
             chart_svg, chart_actual_height = render_chart_item(
                 item.chart,
                 executor,

dataface/core/render/chart/session.py

@@ -23,6 +23,9 @@ from dataface.core.compile.models.chart.resolved import (
     ResolvedSparkBarChart,
     ResolvedTableChart,
 )
+from dataface.core.compile.models.chart.resolved._base import (
+    _SharedResolvedChartFields,
+)
 from dataface.core.compile.models.chart.resolved._layer import LayeredResolvedChart
 from dataface.core.compile.models.style.resolved import ResolvedStyle
 from dataface.core.render.chart._types import VLDict
@@ -134,6 +137,13 @@ class FaceRenderSession:
         spec.title = chart.title
         spec.subtitle = chart.subtitle
         spec.title_font = getattr(chart.style, "title_font", None)
+        # get_emitter above only returns for the VL families, all of which are
+        # _SharedResolvedChartFields subclasses (KPI/callout/table/spark_bar
+        # are dispatched to render_svg_family before this point) — background
+        # and title_style are guaranteed present, so read them directly.
+        assert isinstance(chart, _SharedResolvedChartFields)
+        spec.background = chart.background
+        spec.title_style = chart.title_style
         return spec
 
     def finalize_vl(self, spec: ChartSpec) -> VLDict:

dataface/core/render/chart/spec.py

@@ -20,6 +20,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 if TYPE_CHECKING:
     from dataface.core.compile.models.primitives import ResolvedFontStyle
+    from dataface.core.compile.models.style.theme import TitleStyle
 
 
 @dataclass(frozen=True)
@@ -145,6 +146,8 @@ class ChartSpec:
     title: str | None = None
     subtitle: str | None = None
     title_font: ResolvedFontStyle | None = None
+    background: str | None = None
+    title_style: TitleStyle | None = None
     geo_data: dict[str, Any] | None = None
     transforms: list[dict[str, Any]] = field(default_factory=list)
     # Row data for non-geo VL families; set centrally by FaceRenderSession.emit_chart.

dataface/core/render/chart/spec_builders.py

@@ -7,22 +7,21 @@ from typing import TYPE_CHECKING, Any
 from dataface.core.text.case import apply_case
 
 if TYPE_CHECKING:
-    from dataface.core.compile.models.style.resolved import (
-        ResolvedChartsStyle,
-    )
     from dataface.core.compile.models.style.theme import PaddingStyle
+    from dataface.core.text.case import CaseValue
 
 
 def additive_padding(card_pad: float, chart_padding: PaddingStyle) -> dict[str, float]:
     """Add card_padding to per-family chart padding on each side independently.
 
-    ``chart_padding`` is the per-family resolved padding (from
-    ``effective_chart_padding``) — it already carries face → family fill via
-    InheritSlot and any chart-local ``style.<family>.padding`` override merged
-    in by ``build_resolved_style``. Each side stacks ON TOP of card_padding
-    so author-specified insets compose with the global card layout rather
-    than replacing it. With no chart-local override and face default
-    {0,0,0,0}, this collapses to a uniform card_pad on all four sides.
+    ``chart_padding`` is the per-family resolved padding — typically
+    ``resolved_chart.layout_padding``, baked in at construction time. It
+    already carries face → family fill via InheritSlot and any chart-local
+    ``style.<family>.padding`` override merged in by ``build_resolved_style``.
+    Each side stacks ON TOP of card_padding so author-specified insets compose
+    with the global card layout rather than replacing it. With no chart-local
+    override and face default {0,0,0,0}, this collapses to a uniform
+    card_pad on all four sides.
     """
     return {
         "left": card_pad + chart_padding.left,
@@ -58,18 +57,19 @@ def set_chart_title(
     title: str | None,
     subtitle: str | None = None,
     *,
-    style: ResolvedChartsStyle | None = None,
+    case: CaseValue | None = None,
 ) -> None:
     """Apply a standard title block when a title is present.
 
-    When *style* is provided, ``style.title.font.case`` is applied to the
-    title text. Subtitle is not yet case-transformed here — chart subtitles
-    have always been emitted raw.
+    ``case`` is a plain title-case value (``chart.title_style.font.case``),
+    not a style bag — title-case is VL-presentation-only: ``chart.title``
+    itself stays raw because it also backs non-VL consumers (e.g. the
+    ``data-chart-title`` wire attribute) that emit the authored text as-is.
+    Subtitle is not case-transformed — chart subtitles have always been
+    emitted raw.
     """
-    if title and style is not None:
-        case = style.title.font.case
-        if case is not None and case != "none":
-            title = apply_case(title, case)
+    if title and case is not None and case != "none":
+        title = apply_case(title, case)
     if title or subtitle:
         title_block: dict[str, Any] = {"text": title or ""}
         if subtitle: