matterviz 0.3.7 → 0.4.1

package/dist/plot/{BarPlot.svelte.d.ts → bar/BarPlot.svelte.d.ts}

@@ -1,9 +1,9 @@
-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 { D3InterpolateName } from '../../colors';
+import type { Point2D } from '../../math';
+import type { AxisLoadError, BarHandlerProps, BarMode, BarSeries, BarStyle, BasePlotProps, ColorScaleConfig, DataLoaderFn, InternalPoint, LegendConfig, LineStyle, Orientation, PanConfig, PlotConfig, RefLine, RefLineEvent, SizeScaleConfig, UserContentProps } from '..';
 import type { Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
-import { type TweenOptions } from 'svelte/motion';
+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>[];
@@ -31,16 +31,8 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         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];
-        };
+        color_scale?: ColorScaleConfig | D3InterpolateName;
+        size_scale?: SizeScaleConfig;
         point_tween?: TweenOptions<Point2D>;
         on_point_click?: (data: (BarHandlerProps<Metadata> & {
             point: InternalPoint<Metadata>;
@@ -61,7 +53,7 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         pan?: PanConfig;
     };
     exports: {};
-    bindings: "orientation" | "display" | "mode" | "show_controls" | "x_axis" | "y_axis" | "fullscreen" | "series" | "hovered" | "ref_lines" | "controls_open" | "x2_axis" | "y2_axis";
+    bindings: "display" | "mode" | "orientation" | "show_controls" | "x2_axis" | "y_axis" | "y2_axis" | "fullscreen" | "series" | "hovered" | "ref_lines" | "controls_open" | "x_axis";
     slots: {};
     events: {};
 };
@@ -69,7 +61,7 @@ declare class __sveltets_Render<Metadata extends Record<string, unknown> = Recor
     props(): ReturnType<typeof $$render<Metadata>>['props'];
     events(): ReturnType<typeof $$render<Metadata>>['events'];
     slots(): ReturnType<typeof $$render<Metadata>>['slots'];
-    bindings(): "orientation" | "display" | "mode" | "show_controls" | "x_axis" | "y_axis" | "fullscreen" | "series" | "hovered" | "ref_lines" | "controls_open" | "x2_axis" | "y2_axis";
+    bindings(): "display" | "mode" | "orientation" | "show_controls" | "x2_axis" | "y_axis" | "y2_axis" | "fullscreen" | "series" | "hovered" | "ref_lines" | "controls_open" | "x_axis";
     exports(): {};
 }
 interface $$IsomorphicComponent {

package/dist/plot/{BarPlotControls.svelte → bar/BarPlotControls.svelte}

@@ -1,12 +1,13 @@
 <script lang="ts">
-  import { SettingsSection } from '../layout'
-  import type { BarMode, PlotConfig } from './'
-  import { PlotControls } from './'
-  import type { Orientation, PlotControlsProps } from './types'
+  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 = crypto.randomUUID().slice(0, 8)
+  const uid = unique_id(`bar-ctrl`)
 
   let {
     orientation = $bindable(`vertical`),

package/dist/plot/{BarPlotControls.svelte.d.ts → bar/BarPlotControls.svelte.d.ts}

@@ -1,5 +1,5 @@
-import type { BarMode, PlotConfig } from './';
-import type { Orientation, PlotControlsProps } from './types';
+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;
@@ -13,6 +13,6 @@ type $$ComponentProps = Omit<PlotControlsProps, `children` | `post_children`> &
         } & Required<PlotConfig>
     ]>;
 };
-declare const BarPlotControls: import("svelte").Component<$$ComponentProps, {}, "orientation" | "display" | "mode" | "show_controls" | "x_axis" | "y_axis" | "controls_open" | "x2_axis" | "y2_axis">;
+declare const BarPlotControls: import("svelte").Component<$$ComponentProps, {}, "display" | "mode" | "orientation" | "show_controls" | "x2_axis" | "y_axis" | "y2_axis" | "controls_open" | "x_axis">;
 type BarPlotControls = ReturnType<typeof BarPlotControls>;
 export default BarPlotControls;

package/dist/plot/{SpacegroupBarPlot.svelte → bar/SpacegroupBarPlot.svelte}

@@ -1,10 +1,11 @@
 <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 { format_num, format_value } from '../../labels'
+  import type { Vec2 } from '../../math'
+  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'
 
@@ -123,7 +124,7 @@
   })
 
   // Always show full space group range (1-230)
-  const x_range: [number, number] = [0.5, MAX_SPACEGROUP + 0.5]
+  const x_range: Vec2 = [0.5, MAX_SPACEGROUP + 0.5]
 
   // Calculate crystal system region boundaries using full theoretical ranges
   const crystal_system_regions = $derived.by(() => {

package/dist/plot/{SpacegroupBarPlot.svelte.d.ts → bar/SpacegroupBarPlot.svelte.d.ts}

@@ -1,4 +1,4 @@
-import { BarPlot } from './';
+import { BarPlot } from '..';
 import type { ComponentProps } from 'svelte';
 type $$ComponentProps = ComponentProps<typeof BarPlot> & {
     data: (number | string)[];

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 };
+}

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

@@ -0,0 +1,39 @@
+import type { BarMode, InternalPoint, Orientation } from '../core/types';
+import type { GroupInfo, NumericBarSeries } from './data';
+export type LineSeriesPoint<Metadata = Record<string, unknown>> = InternalPoint<Metadata> & {
+    x: number;
+    y: number;
+    data_x: number;
+    data_y: number;
+    idx: number;
+};
+export declare function compute_line_points<Metadata = Record<string, unknown>>(opts: {
+    series: NumericBarSeries<Metadata>;
+    series_idx: number;
+    orientation: Orientation;
+    x_scale: (val: number) => number;
+    y_scale: (val: number) => number;
+    cat_y_scale: (val: number) => number;
+}): LineSeriesPoint<Metadata>[];
+export interface BarRect {
+    c0: number;
+    c1: number;
+    v0: number;
+    v1: number;
+    rect_x: number;
+    rect_y: number;
+    rect_w: number;
+    rect_h: number;
+}
+export declare function compute_bar_rect(opts: {
+    cat_val: number;
+    val: number;
+    base: number;
+    bar_width_val: number;
+    series_idx: number;
+    mode: BarMode;
+    orientation: Orientation;
+    group_info: GroupInfo;
+    cat_scale: (val: number) => number;
+    val_scale: (val: number) => number;
+}): BarRect;

package/dist/plot/bar/geometry.js

@@ -0,0 +1,60 @@
+// Pure screen-space geometry for BarPlot rendering: line-series point
+// construction and per-bar rect computation. Extracted from BarPlot.svelte's
+// template so the coordinate math is unit-testable.
+import { process_prop } from '../core/data-transform';
+// Build screen-space points for a line series (lines don't stack - they show
+// absolute values). Non-finite points (NaN/Infinity coords) are dropped.
+export function compute_line_points(opts) {
+    const { series: srs, series_idx, orientation, x_scale, y_scale, cat_y_scale } = opts;
+    return srs.x
+        .map((x_val, idx) => {
+        const y_val = srs.y[idx];
+        const plot_x = orientation === `vertical` ? x_scale(x_val) : x_scale(y_val);
+        const plot_y = orientation === `vertical` ? y_scale(y_val) : cat_y_scale(x_val);
+        const metadata = Array.isArray(srs.metadata) ? srs.metadata[idx] : srs.metadata;
+        return {
+            x: plot_x,
+            y: plot_y,
+            data_x: x_val,
+            data_y: y_val,
+            idx,
+            color_value: srs.color_values?.[idx] ?? null,
+            size_value: srs.size_values?.[idx] ?? null,
+            point_style: process_prop(srs.point_style, idx),
+            point_hover: process_prop(srs.point_hover, idx),
+            point_label: process_prop(srs.point_label, idx),
+            point_offset: process_prop(srs.point_offset, idx),
+            metadata,
+            series_idx,
+            point_idx: idx,
+        };
+    })
+        .filter((pt) => isFinite(pt.x) && isFinite(pt.y));
+}
+// Screen-space rect for one bar: category extent (c0/c1) from bar width +
+// grouped offset, value extent (v0/v1) from stacked base to base + value.
+// Rects get min 1px width so thin bars stay visible.
+export function compute_bar_rect(opts) {
+    const { cat_val, val, base, bar_width_val, series_idx, mode, group_info } = opts;
+    const { cat_scale, val_scale } = opts;
+    const is_vertical = opts.orientation === `vertical`;
+    const grouped = mode === `grouped` && group_info.bar_series_count > 1;
+    const half = grouped ? bar_width_val / (2 * group_info.bar_series_count) : bar_width_val / 2;
+    // Offset uses the series' slot among visible bar series (original-index lookup)
+    const group_offset = grouped
+        ? (group_info.bar_series_indices.indexOf(series_idx) -
+            (group_info.bar_series_count - 1) / 2) *
+            (bar_width_val / group_info.bar_series_count)
+        : 0;
+    const c0 = cat_scale(cat_val + group_offset - half);
+    const c1 = cat_scale(cat_val + group_offset + half);
+    const v0 = val_scale(base);
+    const v1 = val_scale(base + val);
+    const [rect_x, rect_y] = is_vertical
+        ? [Math.min(c0, c1), Math.min(v0, v1)]
+        : [Math.min(v0, v1), Math.min(c0, c1)];
+    const [rect_w, rect_h] = is_vertical
+        ? [Math.max(1, Math.abs(c1 - c0)), Math.max(0, Math.abs(v1 - v0))]
+        : [Math.max(1, Math.abs(v1 - v0)), Math.max(0, Math.abs(c1 - c0))];
+    return { c0, c1, v0, v1, rect_x, rect_y, rect_w, rect_h };
+}

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

@@ -0,0 +1,3 @@
+export { default as BarPlot } from './BarPlot.svelte';
+export { default as BarPlotControls } from './BarPlotControls.svelte';
+export { default as SpacegroupBarPlot } from './SpacegroupBarPlot.svelte';

package/dist/plot/bar/index.js

@@ -0,0 +1,3 @@
+export { default as BarPlot } from './BarPlot.svelte';
+export { default as BarPlotControls } from './BarPlotControls.svelte';
+export { default as SpacegroupBarPlot } from './SpacegroupBarPlot.svelte';