matterviz 0.3.6 → 0.4.0

package/dist/plot/bar/BarPlot.svelte.d.ts

@@ -0,0 +1,84 @@
+import type { D3ColorSchemeName, D3InterpolateName } from '../../colors';
+import type { Point2D } from '../../math';
+import type { AxisLoadError, BarHandlerProps, BarMode, BarSeries, BarStyle, BasePlotProps, DataLoaderFn, InternalPoint, LegendConfig, LineStyle, Orientation, PanConfig, PlotConfig, RefLine, RefLineEvent, ScaleType, UserContentProps } from '..';
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import { type TweenOptions } from 'svelte/motion';
+declare function $$render<Metadata extends Record<string, unknown> = Record<string, unknown>>(): {
+    props: HTMLAttributes<HTMLDivElement> & BasePlotProps & PlotConfig & {
+        series?: BarSeries<Metadata>[];
+        orientation?: Orientation;
+        mode?: BarMode;
+        legend?: LegendConfig | null;
+        show_legend?: boolean;
+        bar?: BarStyle;
+        line?: LineStyle;
+        tooltip?: Snippet<[BarHandlerProps<Metadata>]>;
+        user_content?: Snippet<[UserContentProps]>;
+        header_controls?: Snippet<[{
+            height: number;
+            width: number;
+            fullscreen: boolean;
+        }]>;
+        controls_extra?: Snippet<[{
+            orientation: Orientation;
+            mode: BarMode;
+        } & Required<PlotConfig>]>;
+        change?: (data: BarHandlerProps<Metadata> | null) => void;
+        on_bar_click?: (data: BarHandlerProps<Metadata> & {
+            event: MouseEvent | KeyboardEvent;
+        }) => void;
+        on_bar_hover?: (data: (BarHandlerProps<Metadata> & {
+            event: MouseEvent | FocusEvent | KeyboardEvent;
+        }) | null) => void;
+        color_scale?: {
+            type?: ScaleType;
+            scheme?: D3ColorSchemeName | D3InterpolateName;
+            value_range?: [number, number];
+        } | D3InterpolateName;
+        size_scale?: {
+            type?: ScaleType;
+            radius_range?: [number, number];
+            value_range?: [number, number];
+        };
+        point_tween?: TweenOptions<Point2D>;
+        on_point_click?: (data: (BarHandlerProps<Metadata> & {
+            point: InternalPoint<Metadata>;
+        }) & {
+            event: MouseEvent | KeyboardEvent;
+        }) => void;
+        on_point_hover?: (data: ((BarHandlerProps<Metadata> & {
+            point: InternalPoint<Metadata>;
+        }) & {
+            event: MouseEvent | FocusEvent | KeyboardEvent;
+        }) | null) => void;
+        ref_lines?: RefLine[];
+        on_ref_line_click?: (event: RefLineEvent) => void;
+        on_ref_line_hover?: (event: RefLineEvent | null) => void;
+        data_loader?: DataLoaderFn<Metadata, BarSeries<Metadata>>;
+        on_axis_change?: (axis: `x` | `x2` | `y` | `y2`, key: string, new_series: BarSeries<Metadata>[]) => void;
+        on_error?: (error: AxisLoadError) => void;
+        pan?: PanConfig;
+    };
+    exports: {};
+    bindings: "orientation" | "display" | "mode" | "show_controls" | "fullscreen" | "series" | "hovered" | "ref_lines" | "controls_open" | "x_axis" | "y_axis" | "x2_axis" | "y2_axis";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Metadata extends Record<string, unknown> = Record<string, unknown>> {
+    props(): ReturnType<typeof $$render<Metadata>>['props'];
+    events(): ReturnType<typeof $$render<Metadata>>['events'];
+    slots(): ReturnType<typeof $$render<Metadata>>['slots'];
+    bindings(): "orientation" | "display" | "mode" | "show_controls" | "fullscreen" | "series" | "hovered" | "ref_lines" | "controls_open" | "x_axis" | "y_axis" | "x2_axis" | "y2_axis";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Metadata extends Record<string, unknown> = Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Metadata>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Metadata>['props']>, ReturnType<__sveltets_Render<Metadata>['events']>, ReturnType<__sveltets_Render<Metadata>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Metadata>['bindings']>;
+    } & ReturnType<__sveltets_Render<Metadata>['exports']>;
+    <Metadata extends Record<string, unknown> = Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<Metadata>['props']> & {}): ReturnType<__sveltets_Render<Metadata>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const BarPlot: $$IsomorphicComponent;
+type BarPlot<Metadata extends Record<string, unknown> = Record<string, unknown>> = InstanceType<typeof BarPlot<Metadata>>;
+export default BarPlot;

package/dist/plot/bar/BarPlotControls.svelte

@@ -0,0 +1,67 @@
+<script lang="ts">
+  import { SettingsSection } from '../../layout'
+  import type { BarMode, PlotConfig } from '..'
+  import { PlotControls } from '..'
+  import type { Orientation, PlotControlsProps } from '../core/types'
+  import { unique_id } from '../core/utils'
+  import type { Snippet } from 'svelte'
+
+  // Unique ID prefix to avoid conflicts when multiple instances on same page
+  const uid = unique_id(`bar-ctrl`)
+
+  let {
+    orientation = $bindable(`vertical`),
+    mode = $bindable(`overlay`),
+    x_axis = $bindable({}),
+    x2_axis = $bindable({}),
+    y_axis = $bindable({}),
+    y2_axis = $bindable({}),
+    display = $bindable({}),
+    show_controls = $bindable(false),
+    controls_open = $bindable(false),
+    children,
+    ...rest
+  }: Omit<PlotControlsProps, `children` | `post_children`> & {
+    orientation?: Orientation
+    mode?: BarMode
+    show_controls?: boolean
+    controls_open?: boolean
+    children?: Snippet<
+      [{ orientation: Orientation; mode: BarMode } & Required<PlotConfig>]
+    >
+  } = $props()
+</script>
+
+<PlotControls
+  bind:show_controls
+  bind:controls_open
+  bind:x_axis
+  bind:x2_axis
+  bind:y_axis
+  bind:y2_axis
+  bind:display
+  {...rest}
+>
+  {@render children?.({ orientation, mode, x_axis, x2_axis, y_axis, y2_axis, display })}
+  <SettingsSection
+    title="Layout"
+    current_values={{ orientation, mode }}
+    style="display: flex; gap: 2ex"
+  >
+    <label style="flex: 1">
+      Orientation:
+      <select bind:value={orientation} id="{uid}-orientation">
+        <option value="vertical">Vertical</option>
+        <option value="horizontal">Horizontal</option>
+      </select>
+    </label>
+    <label style="flex: 1">
+      Mode:
+      <select bind:value={mode} id="{uid}-mode">
+        <option value="overlay">Overlay</option>
+        <option value="stacked">Stacked</option>
+        <option value="grouped">Grouped (Side-by-Side)</option>
+      </select>
+    </label>
+  </SettingsSection>
+</PlotControls>

package/dist/plot/bar/BarPlotControls.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { BarMode, PlotConfig } from '..';
+import type { Orientation, PlotControlsProps } from '../core/types';
+import type { Snippet } from 'svelte';
+type $$ComponentProps = Omit<PlotControlsProps, `children` | `post_children`> & {
+    orientation?: Orientation;
+    mode?: BarMode;
+    show_controls?: boolean;
+    controls_open?: boolean;
+    children?: Snippet<[
+        {
+            orientation: Orientation;
+            mode: BarMode;
+        } & Required<PlotConfig>
+    ]>;
+};
+declare const BarPlotControls: import("svelte").Component<$$ComponentProps, {}, "orientation" | "display" | "mode" | "show_controls" | "controls_open" | "x_axis" | "y_axis" | "x2_axis" | "y2_axis">;
+type BarPlotControls = ReturnType<typeof BarPlotControls>;
+export default BarPlotControls;

package/dist/plot/bar/SpacegroupBarPlot.svelte

@@ -0,0 +1,293 @@
+<script lang="ts">
+  import { format_num, format_value } from '../../labels'
+  import type { BarHandlerProps, BarSeries, TickConfig } from '..'
+  import { BarPlot } from '..'
+  import type { CrystalSystem } from '../../symmetry'
+  import * as symmetry from '../../symmetry'
+  import * as spg from '../../symmetry/spacegroups'
+  import type { ComponentProps } from 'svelte'
+  import { SvelteMap } from 'svelte/reactivity'
+
+  // Merge tick config with default rotation, preserving user overrides
+  const with_rotation = (
+    tick: TickConfig | undefined,
+    default_rot: number,
+  ): TickConfig => ({
+    ...tick,
+    label: { ...tick?.label, rotation: tick?.label?.rotation ?? default_rot },
+  })
+
+  const MAX_SPACEGROUP = 230
+  let {
+    data,
+    show_counts = true,
+    show_legend = false,
+    orientation = `vertical`,
+    x_axis = {},
+    y_axis = {},
+    ...rest
+  }: ComponentProps<typeof BarPlot> & {
+    data: (number | string)[]
+    show_counts?: boolean
+  } = $props()
+
+  // Normalize input data to space group numbers
+  const normalized_data = $derived(
+    data.map(spg.normalize_spacegroup).filter((sg): sg is number => sg !== null),
+  )
+
+  // Compute histogram of space group numbers
+  const histogram = $derived.by(() => {
+    const hist = new SvelteMap<number, number>()
+
+    // Count occurrences
+    for (const sg of normalized_data) {
+      hist.set(sg, (hist.get(sg) ?? 0) + 1)
+    }
+
+    return hist
+  })
+
+  // Group counts by crystal system
+  const crystal_system_stats = $derived.by(() => {
+    const stats = new SvelteMap<
+      CrystalSystem,
+      { count: number; spacegroups: number[] }
+    >()
+
+    for (const system of symmetry.CRYSTAL_SYSTEMS) {
+      stats.set(system, { count: 0, spacegroups: [] })
+    }
+
+    for (const [sg, count] of histogram) {
+      const system = spg.spacegroup_to_crystal_sys(sg)
+      if (!system) continue
+      const stat = stats.get(system)
+      if (!stat) continue
+      stat.count += count
+      stat.spacegroups.push(sg)
+    }
+
+    return stats
+  })
+
+  // Create sorted list of space groups for x-axis
+  const sorted_spacegroups = $derived(
+    Array.from(histogram.keys()).sort((a, b) => a - b),
+  )
+
+  // Smart tick selection: thin out ticks for dense data
+  const x_axis_ticks = $derived.by(() => {
+    const non_zero_count = sorted_spacegroups.filter(
+      (sg) => (histogram.get(sg) ?? 0) > 0,
+    ).length
+
+    // If data is dense (>40 space groups with data), show only multiples of 5
+    return non_zero_count > 40
+      ? sorted_spacegroups.filter((sg) => sg % 5 === 0)
+      : sorted_spacegroups
+  })
+
+  // Build BarSeries - one series per crystal system for proper coloring
+  const bar_series = $derived.by<BarSeries[]>(() => {
+    const series_by_system = new SvelteMap<
+      CrystalSystem,
+      { x: number[]; y: number[] }
+    >()
+
+    // Group data by crystal system
+    for (const sg of sorted_spacegroups) {
+      const system = spg.spacegroup_to_crystal_sys(sg)
+      if (system) {
+        let series = series_by_system.get(system)
+        if (!series) {
+          series = { x: [], y: [] }
+          series_by_system.set(system, series)
+        }
+        series.x.push(sg)
+        series.y.push(histogram.get(sg) ?? 0)
+      }
+    }
+
+    // Convert to BarSeries array, maintaining order of crystal systems
+    const result: BarSeries[] = []
+    for (const system of symmetry.CRYSTAL_SYSTEMS) {
+      const system_data = series_by_system.get(system)
+      if (system_data) {
+        const { x, y } = system_data
+        const color = symmetry.CRYSTAL_SYSTEM_COLORS[system]
+        result.push({ x, y, color, label: system, bar_width: 0.9, visible: true })
+      }
+    }
+    return result
+  })
+
+  // Always show full space group range (1-230)
+  const x_range: [number, number] = [0.5, MAX_SPACEGROUP + 0.5]
+
+  // Calculate crystal system region boundaries using full theoretical ranges
+  const crystal_system_regions = $derived.by(() => {
+    const [range_min, range_max] = x_range
+
+    return symmetry.CRYSTAL_SYSTEMS.map((system) => {
+      const [sg_start, sg_end] = symmetry.CRYSTAL_SYSTEM_RANGES[system]
+      const stats = crystal_system_stats.get(system)
+      const count = stats?.count ?? 0
+      const color = symmetry.CRYSTAL_SYSTEM_COLORS[system]
+      return { system, sg_start, sg_end, count, color }
+    }).filter(
+      (region) => region.sg_end >= range_min && region.sg_start <= range_max, // Only visible systems
+    )
+  })
+
+  const total_count = $derived(normalized_data.length)
+
+  // Build axis configurations based on orientation
+  const x_axis_config = $derived(
+    orientation === `horizontal` ? { ...x_axis, label: x_axis.label ?? `Counts` } : {
+      ...x_axis,
+      label: x_axis.label ?? `International Spacegroup Number`,
+      range: x_range,
+      ticks: x_axis_ticks,
+      tick: with_rotation(x_axis.tick, 90), // Rotate ticks 90° to avoid overlap
+      label_shift: { x: 0, y: 20, ...x_axis.label_shift }, // Move label down for rotated ticks
+    },
+  )
+
+  const y_axis_config = $derived(
+    orientation === `horizontal`
+      ? {
+        ...y_axis,
+        label: y_axis.label ?? `International Spacegroup Number`,
+        range: x_range,
+        ticks: x_axis_ticks,
+        tick: with_rotation(y_axis.tick, 0),
+      }
+      : { ...y_axis, label: y_axis.label ?? `Counts` },
+  )
+</script>
+
+{#snippet tooltip(info: BarHandlerProps)}
+  {@const { x: sg, y: count } = info}
+  {@const system = spg.spacegroup_to_crystal_sys(sg)}
+  Space Group: {format_value(sg, `.0f`)} ({spg.SPACEGROUP_NUM_TO_SYMBOL[sg]})<br />
+  {#if system}
+    Crystal System: {system}<br />
+  {/if}
+  Count: {format_value(count, `.0f`)}
+{/snippet}
+
+{#snippet user_content({ width, height, x_scale_fn, y_scale_fn, pad }: {
+  width: number
+  height: number
+  x_scale_fn: (x: number) => number
+  y_scale_fn: (y: number) => number
+  pad: { t: number; b: number; l: number; r: number }
+})}
+  <g class="crystal-system-overlays" pointer-events="none">
+    {#each crystal_system_regions as region (region.system)}
+      {#if orientation === `vertical`}
+        {@const x_start = x_scale_fn(region.sg_start - 0.5)}
+        {@const x_end = x_scale_fn(region.sg_end + 0.5)}
+        {@const x_center = (x_start + x_end) / 2}
+        {@const rect_width = x_end - x_start}
+        <!-- Background colored rectangle (vertical mode) -->
+        <rect
+          x={x_start}
+          y={pad.t}
+          width={rect_width}
+          height={height - pad.t - pad.b}
+          fill={region.color}
+          opacity="0.15"
+          stroke={region.color}
+          stroke-width="1"
+          stroke-opacity="0.3"
+        />
+        <!-- Crystal system label (rotated 90 degrees) at top edge -->
+        <text
+          x={x_center}
+          y={pad.t + 15}
+          text-anchor="start"
+          font-size="14"
+          fill="var(--text-color, black)"
+          opacity="0.6"
+          transform="rotate(90, {x_center}, {pad.t + 15})"
+        >
+          {region.system}
+        </text>
+        <!-- Count annotation at top -->
+        {#if show_counts && total_count > 0}
+          {@const y_offset = region.system === `triclinic` ? -20 : -5}
+          <text
+            x={x_center}
+            y={pad.t + y_offset}
+            text-anchor="middle"
+            font-size="12"
+            fill="var(--text-color, black)"
+          >
+            {format_num(region.count, `,~`)} ({
+              format_num(region.count / total_count, `.1~%`)
+            })
+          </text>
+        {/if}
+      {:else}
+        {@const y_start = y_scale_fn(region.sg_end + 0.5)}
+        {@const y_end = y_scale_fn(region.sg_start - 0.5)}
+        {@const y_center = (y_start + y_end) / 2}
+        {@const rect_height = y_end - y_start}
+        <!-- Background colored rectangle (horizontal mode) -->
+        <rect
+          x={pad.l}
+          y={y_start}
+          width={width - pad.l - pad.r}
+          height={rect_height}
+          fill={region.color}
+          opacity="0.15"
+          stroke={region.color}
+          stroke-width="1"
+          stroke-opacity="0.3"
+        />
+        <!-- Crystal system label (horizontal) at left edge -->
+        <text
+          x={width - pad.r - 8}
+          y={y_center}
+          text-anchor="end"
+          dominant-baseline="central"
+          font-size="14"
+          fill="var(--text-color, black)"
+          opacity="0.6"
+        >
+          {region.system}
+        </text>
+        <!-- Count annotation at right -->
+        {#if show_counts && total_count > 0}
+          <text
+            x={width - pad.r + 5}
+            y={y_center}
+            text-anchor="start"
+            dominant-baseline="central"
+            font-size="12"
+            fill="var(--text-color, black)"
+          >
+            {format_num(region.count, `,~`)} ({
+              format_num(region.count / total_count, `.1~%`)
+            })
+          </text>
+        {/if}
+      {/if}
+    {/each}
+  </g>
+{/snippet}
+
+<BarPlot
+  {...rest}
+  series={bar_series}
+  {orientation}
+  mode="overlay"
+  x_axis={x_axis_config}
+  y_axis={y_axis_config}
+  {show_legend}
+  show_controls={false}
+  {tooltip}
+  {user_content}
+/>

package/dist/plot/bar/SpacegroupBarPlot.svelte.d.ts

@@ -0,0 +1,9 @@
+import { BarPlot } from '..';
+import type { ComponentProps } from 'svelte';
+type $$ComponentProps = ComponentProps<typeof BarPlot> & {
+    data: (number | string)[];
+    show_counts?: boolean;
+};
+declare const SpacegroupBarPlot: import("svelte").Component<$$ComponentProps, {}, "">;
+type SpacegroupBarPlot = ReturnType<typeof SpacegroupBarPlot>;
+export default SpacegroupBarPlot;

package/dist/plot/bar/data.d.ts

@@ -0,0 +1,40 @@
+import type { BarMode, BarSeries, Orientation, ScaleType } from '../core/types';
+export type NumericBarSeries<Metadata = Record<string, unknown>> = Omit<BarSeries<Metadata>, `x`> & {
+    x: readonly number[];
+};
+export declare function normalize_categorical<Metadata = Record<string, unknown>>(series: readonly BarSeries<Metadata>[], explicit_categories?: readonly string[]): {
+    category_list: string[];
+    internal_series: NumericBarSeries<Metadata>[];
+};
+export interface BarAutoRangeOpts<Metadata = Record<string, unknown>> {
+    visible_series: readonly NumericBarSeries<Metadata>[];
+    y1_series: readonly NumericBarSeries<Metadata>[];
+    y2_series: readonly NumericBarSeries<Metadata>[];
+    x2_series: readonly NumericBarSeries<Metadata>[];
+    mode: BarMode;
+    orientation: Orientation;
+    range_padding: number;
+    category_count: number;
+    x_range: [number | null, number | null];
+    x_scale_type: ScaleType;
+    x_is_time: boolean;
+    x2_range: [number | null, number | null];
+    x2_scale_type: ScaleType;
+    x2_is_time: boolean;
+    y_range: [number | null, number | null];
+    y_scale_type: ScaleType;
+    y2_range: [number | null, number | null];
+    y2_scale_type: ScaleType;
+}
+export declare function compute_bar_auto_ranges<Metadata = Record<string, unknown>>(opts: BarAutoRangeOpts<Metadata>): {
+    x: number[];
+    x2: number[];
+    y: number[];
+    y2: number[];
+};
+export declare function compute_stacked_offsets<Metadata = Record<string, unknown>>(internal_series: readonly NumericBarSeries<Metadata>[], mode: BarMode): number[][];
+export interface GroupInfo {
+    bar_series_count: number;
+    bar_series_indices: number[];
+}
+export declare function compute_group_info<Metadata = Record<string, unknown>>(internal_series: readonly NumericBarSeries<Metadata>[], mode: BarMode): GroupInfo;

package/dist/plot/bar/data.js

@@ -0,0 +1,154 @@
+// Pure data-shaping logic for BarPlot: categorical x-value normalization,
+// auto-range computation (incl. stacked totals + zero-clamping), stacked-bar
+// offsets and grouped-bar layout info. Extracted from BarPlot.svelte so the
+// math is unit-testable without mounting the component.
+import { get_nice_data_range } from '../core/scales';
+import { get_scale_type_name } from '../core/types';
+// Map string x values (categories) to integer indices shared across all series.
+// Numeric-only input is passed through unchanged (same array identity).
+export function normalize_categorical(series, explicit_categories) {
+    const is_categorical = series.some((srs) => srs.x.some((val) => typeof val === `string`));
+    const category_list = !is_categorical
+        ? []
+        : explicit_categories?.length
+            ? [...explicit_categories]
+            : [...new Set(series.flatMap((srs) => srs.x.map(String)))];
+    if (category_list.length === 0) {
+        // safe: when no categories were found, all x values are numeric
+        const internal_series = series;
+        return { category_list, internal_series };
+    }
+    const category_indices = category_list.map((_, idx) => idx);
+    const internal_series = series.map((srs) => {
+        const orig_map = new Map(srs.x.map((val, idx) => [String(val), idx]));
+        if (orig_map.size < srs.x.length) {
+            console.warn(`BarPlot: series "${srs.label ?? `?`}" has duplicate x values — last occurrence wins`);
+        }
+        // Resolve original index for each category (undefined if series lacks it)
+        const orig_indices = category_list.map((cat) => orig_map.get(cat));
+        const remap = (arr, fallback) => orig_indices.map((oi) => (oi != null ? (arr?.[oi] ?? fallback) : fallback));
+        // Reorder a per-point prop that may be a single value (broadcast, left as-is) or an
+        // array (must follow the category reordering, else point styles misalign with bars)
+        const remap_per_point = (prop) => Array.isArray(prop)
+            ? orig_indices.map((oi) => (oi != null ? prop[oi] : undefined))
+            : prop;
+        const bw_arr = Array.isArray(srs.bar_width) ? srs.bar_width : null;
+        const meta_arr = Array.isArray(srs.metadata) ? srs.metadata : null;
+        return {
+            ...srs,
+            x: category_indices,
+            y: remap(srs.y, srs.render_mode === `line` ? NaN : 0),
+            labels: remap(srs.labels, null),
+            metadata: orig_indices.map((oi) => oi != null ? (meta_arr ? meta_arr[oi] : srs.metadata) : undefined),
+            point_style: remap_per_point(srs.point_style),
+            point_hover: remap_per_point(srs.point_hover),
+            point_label: remap_per_point(srs.point_label),
+            point_offset: remap_per_point(srs.point_offset),
+            ...(bw_arr ? { bar_width: remap(bw_arr, 0.5) } : {}),
+            ...(srs.color_values ? { color_values: remap(srs.color_values, null) } : {}),
+            ...(srs.size_values ? { size_values: remap(srs.size_values, null) } : {}),
+        };
+    });
+    return { category_list, internal_series };
+}
+// Compute data-driven axis ranges for all four axes. In stacked mode the value
+// range covers per-x stacked totals (positive and negative stacks separately);
+// for linear/arcsinh scales the value axis is clamped to include 0 when all
+// values share one sign and no explicit range is set.
+export function compute_bar_auto_ranges(opts) {
+    const { visible_series, mode, orientation, range_padding, category_count } = opts;
+    const calc_y_range = (series_list, y_limit, scale_type) => {
+        let points = series_list.flatMap((srs) => srs.x.map((x_val, idx) => ({ x: x_val, y: srs.y[idx] })));
+        // In stacked mode, calculate stacked totals for accurate range (only for bars on the same axis)
+        if (mode === `stacked`) {
+            const stacked_totals = new Map();
+            // Only include visible bar series (not lines) in stacking
+            series_list
+                .filter((srs) => srs.render_mode !== `line`)
+                .forEach((srs) => srs.x.forEach((x_val, idx) => {
+                const y_val = srs.y[idx] ?? 0;
+                const totals = stacked_totals.get(x_val) ?? { pos: 0, neg: 0 };
+                if (y_val >= 0)
+                    totals.pos += y_val;
+                else
+                    totals.neg += y_val;
+                stacked_totals.set(x_val, totals);
+            }));
+            // Replace points with stacked totals + line series (which don't stack)
+            points = [
+                ...Array.from(stacked_totals).flatMap(([x_val, { pos, neg }]) => [
+                    ...(pos > 0 ? [{ x: x_val, y: pos }] : []),
+                    ...(neg < 0 ? [{ x: x_val, y: neg }] : []),
+                ]),
+                ...series_list
+                    .filter((srs) => srs.render_mode === `line`)
+                    .flatMap((srs) => srs.x.map((x_val, idx) => ({ x: x_val, y: srs.y[idx] }))),
+            ];
+        }
+        if (points.length === 0)
+            return [0, 1];
+        let computed_y_range = get_nice_data_range(points, (pt) => pt.y, y_limit, scale_type, range_padding, false);
+        // Bar value axes include 0 when all values share one sign - unless an explicit
+        // range is set or the scale is log (where 0 is invalid)
+        const type_name = get_scale_type_name(scale_type);
+        if ((type_name === `linear` || type_name === `arcsinh`) &&
+            y_limit[0] == null &&
+            y_limit[1] == null) {
+            const has_negative = points.some((pt) => pt.y < 0);
+            const has_positive = points.some((pt) => pt.y > 0);
+            if (has_positive && !has_negative)
+                computed_y_range = [0, computed_y_range[1]];
+            else if (has_negative && !has_positive)
+                computed_y_range = [computed_y_range[0], 0];
+        }
+        return computed_y_range;
+    };
+    const calc_x_range = (series_list, limit, scale_type, is_time) => {
+        const points = series_list.flatMap((srs) => srs.x.map((x_val) => ({ x: x_val, y: 0 })));
+        if (points.length === 0)
+            return [0, 1];
+        return get_nice_data_range(points, (pt) => pt.x, limit, scale_type, range_padding, is_time);
+    };
+    // Categorical x axes use a fixed range centered on integer indices
+    const x_auto_range = category_count > 0
+        ? [-0.5, category_count - 0.5]
+        : calc_x_range(visible_series.filter((srs) => (srs.x_axis ?? `x1`) === `x1`), opts.x_range, opts.x_scale_type, opts.x_is_time);
+    const x2_auto_range = calc_x_range(opts.x2_series, opts.x2_range, opts.x2_scale_type, opts.x2_is_time);
+    const y1_range = calc_y_range(opts.y1_series, opts.y_range, opts.y_scale_type);
+    const y2_auto_range = calc_y_range(opts.y2_series, opts.y2_range, opts.y2_scale_type);
+    // Map data ranges to axis ranges depending on orientation
+    return orientation === `horizontal`
+        ? { x: y1_range, x2: x2_auto_range, y: x_auto_range, y2: y2_auto_range }
+        : { x: x_auto_range, x2: x2_auto_range, y: y1_range, y2: y2_auto_range };
+}
+// Stack offsets indexed by [original series idx][bar idx] (only bar series in
+// stacked mode contribute; hidden and line series get all-zero rows).
+export function compute_stacked_offsets(internal_series, mode) {
+    if (mode !== `stacked`)
+        return [];
+    const offsets = internal_series.map((srs) => Array.from(srs.x, () => 0));
+    // Cumulative totals keyed by axis/sign/x value so series with misaligned x grids
+    // stack on the correct baseline (matching stacked totals in compute_bar_auto_ranges)
+    const acc = new Map();
+    internal_series.forEach((srs, series_idx) => {
+        if (!(srs?.visible ?? true) || srs.render_mode === `line`)
+            return;
+        srs.x.forEach((x_val, bar_idx) => {
+            const y_val = srs.y[bar_idx] ?? 0;
+            const key = `${srs.y_axis === `y2` ? `y2` : `y1`}:${y_val >= 0 ? `+` : `-`}:${x_val}`;
+            offsets[series_idx][bar_idx] = acc.get(key) ?? 0;
+            acc.set(key, (acc.get(key) ?? 0) + y_val);
+        });
+    });
+    return offsets;
+}
+// Group positions for grouped mode (side-by-side bars). Indices are original
+// series indices so hidden/line series don't shift visible bars' slots.
+export function compute_group_info(internal_series, mode) {
+    if (mode !== `grouped`)
+        return { bar_series_count: 0, bar_series_indices: [] };
+    const bar_series_indices = internal_series
+        .map((srs, idx) => ((srs?.visible ?? true) && srs.render_mode !== `line` ? idx : -1))
+        .filter((idx) => idx >= 0);
+    return { bar_series_count: bar_series_indices.length, bar_series_indices };
+}