matterviz 0.3.0 → 0.3.2

package/dist/plot/reference-line.js

@@ -48,77 +48,7 @@ export function normalize_value(value) {
     return 0;
 }
 // Normalize a point tuple
-export function normalize_point(point) {
-    return [normalize_value(point[0]), normalize_value(point[1])];
-}
-// Create a horizontal reference line at y = value
-export function horizontal_line(y_value, opts) {
-    return { type: `horizontal`, y: y_value, ...opts };
-}
-// Create a vertical reference line at x = value
-export function vertical_line(x_value, opts) {
-    return { type: `vertical`, x: x_value, ...opts };
-}
-// Create a diagonal reference line with y = slope * x + intercept
-export function diagonal_line(slope, intercept, opts) {
-    return { type: `diagonal`, slope, intercept, ...opts };
-}
-// Create a line segment between two points
-export function line_segment(p1, p2, opts) {
-    return { type: `segment`, p1, p2, ...opts };
-}
-// Create a line through two points, extended to plot edges
-export function line_through(p1, p2, opts) {
-    return { type: `line`, p1, p2, ...opts };
-}
-// Batch helper: create multiple horizontal lines
-export function horizontal_lines(values, opts) {
-    return values.map((y_value) => horizontal_line(y_value, opts));
-}
-// Batch helper: create multiple vertical lines
-export function vertical_lines(values, opts) {
-    return values.map((x_value) => vertical_line(x_value, opts));
-}
-// Create an XY plane at z = value (horizontal plane)
-export function plane_xy(z_value, opts) {
-    return { type: `xy`, z: z_value, ...opts };
-}
-// Create an XZ plane at y = value
-export function plane_xz(y_value, opts) {
-    return { type: `xz`, y: y_value, ...opts };
-}
-// Create a YZ plane at x = value
-export function plane_yz(x_value, opts) {
-    return { type: `yz`, x: x_value, ...opts };
-}
-// Create a plane defined by normal vector and a point on the plane
-export function plane_normal(normal, point, opts) {
-    return { type: `normal`, normal, point, ...opts };
-}
-// Create a plane through three points
-export function plane_through_points(p1, p2, p3, opts) {
-    return { type: `points`, p1, p2, p3, ...opts };
-}
-// Create a 3D line parallel to x-axis at given y, z
-export function line_x_axis(y_value, z_value, opts) {
-    return { type: `x-axis`, y: y_value, z: z_value, ...opts };
-}
-// Create a 3D line parallel to y-axis at given x, z
-export function line_y_axis(x_value, z_value, opts) {
-    return { type: `y-axis`, x: x_value, z: z_value, ...opts };
-}
-// Create a 3D line parallel to z-axis at given x, y
-export function line_z_axis(x_value, y_value, opts) {
-    return { type: `z-axis`, x: x_value, y: y_value, ...opts };
-}
-// Create a 3D line segment between two points
-export function line_segment_3d(p1, p2, opts) {
-    return { type: `segment`, p1, p2, ...opts };
-}
-// Create a 3D line through two points, extended to bounds
-export function line_through_3d(p1, p2, opts) {
-    return { type: `line`, p1, p2, ...opts };
-}
+export const normalize_point = (point) => [normalize_value(point[0]), normalize_value(point[1])];
 // Clip a line segment to a rectangle using Liang-Barsky algorithm
 // Returns clipped [x1, y1, x2, y2] or null if segment is entirely outside
 function clip_segment_to_rect(p1x, p1y, p2x, p2y, x_min, x_max, y_min, y_max) {
@@ -147,17 +77,13 @@ function clip_segment_to_rect(p1x, p1y, p2x, p2y, x_min, x_max, y_min, y_max) {
     }
     if (t_enter > t_leave)
         return null; // Segment entirely outside
-    return [
-        p1x + t_enter * dx,
-        p1y + t_enter * dy,
-        p1x + t_leave * dx,
-        p1y + t_leave * dy,
-    ];
+    return [p1x + t_enter * dx, p1y + t_enter * dy, p1x + t_leave * dx, p1y + t_leave * dy];
 }
 // Compute the screen coordinates for a reference line
 // Returns [x1, y1, x2, y2] in pixel coordinates, or null if line is not visible
-export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max }, { x_scale, y_scale, y2_scale }) {
-    // Determine which y-scale to use
+export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max }, { x_scale, x2_scale, y_scale, y2_scale }) {
+    // Determine which scales to use based on axis assignment
+    const active_x_scale = ref_line.x_axis === `x2` && x2_scale ? x2_scale : x_scale;
     const active_y_scale = ref_line.y_axis === `y2` && y2_scale ? y2_scale : y_scale;
     // Check if value is within plot bounds (for visibility)
     const is_x_visible = (x_val) => x_val >= x_min && x_val <= x_max;
@@ -273,9 +199,9 @@ export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max },
         return null;
     }
     // Convert data coordinates to screen pixels
-    const x1_px = x_scale(x1_data);
+    const x1_px = active_x_scale(x1_data);
     const y1_px = active_y_scale(y1_data);
-    const x2_px = x_scale(x2_data);
+    const x2_px = active_x_scale(x2_data);
     const y2_px = active_y_scale(y2_data);
     // Validate that pixels are finite
     if (!isFinite(x1_px) || !isFinite(y1_px) || !isFinite(x2_px) || !isFinite(y2_px)) {

package/dist/plot/types.d.ts

@@ -1,5 +1,5 @@
 import type { D3SymbolName } from '../labels';
-import type { Vec3 } from '../math';
+import type { Vec2, Vec3 } from '../math';
 import type DraggablePane from '../overlays/DraggablePane.svelte';
 import type { SimulationNodeDatum } from 'd3-force';
 import type { ComponentProps, Snippet } from 'svelte';
@@ -27,6 +27,12 @@ export type Sides = {
     l?: number;
     r?: number;
 };
+export type InitialRanges = {
+    initial_x_range: Vec2;
+    initial_x2_range: Vec2;
+    initial_y_range: Vec2;
+    initial_y2_range: Vec2;
+};
 export type Point<Metadata = Record<string, unknown>> = {
     x: number;
     y: number;
@@ -93,6 +99,7 @@ export interface DataSeries<Metadata = Record<string, unknown>> {
     x: readonly number[];
     y: readonly number[];
     markers?: Markers;
+    x_axis?: `x1` | `x2`;
     y_axis?: `y1` | `y2`;
     color_values?: (number | null)[] | null;
     size_values?: readonly (number | null)[] | null;
@@ -138,6 +145,7 @@ export interface HandlerProps<Metadata = Record<string, unknown>> {
     label?: string | null;
     series_idx: number;
     x_axis: AxisConfig;
+    x2_axis?: AxisConfig;
     y_axis: AxisConfig;
     y2_axis?: AxisConfig;
     fullscreen?: boolean;
@@ -164,13 +172,16 @@ export interface BarHandlerProps<Metadata = Record<string, unknown>> extends Han
     orient_x: number;
     orient_y: number;
     active_y_axis: `y1` | `y2`;
+    active_x_axis: `x1` | `x2`;
     color: string;
+    category_label?: string;
 }
 export interface HistogramHandlerProps<Metadata = Record<string, unknown>> extends HandlerProps<Metadata> {
     value: number;
     count: number;
     property: string;
     active_y_axis: `y1` | `y2`;
+    active_x_axis: `x1` | `x2`;
 }
 export type TimeInterval = `day` | `month` | `year`;
 export type ScaleTypeName = `linear` | `log` | `arcsinh` | `time`;
@@ -179,6 +190,7 @@ export interface ArcsinhScaleConfig {
     threshold?: number;
 }
 export type ScaleType = `linear` | `log` | `arcsinh` | `time` | ArcsinhScaleConfig;
+export declare function is_scale_type_name(val: string): val is ScaleTypeName;
 export declare function get_scale_type_name(scale_type: ScaleType | undefined): ScaleTypeName;
 export declare function get_arcsinh_threshold(scale_type: ScaleType | undefined): number;
 export declare function is_time_scale(scale_type: ScaleType | undefined, format: string | undefined): boolean;
@@ -246,19 +258,21 @@ export type UserContentProps = {
     height: number;
     width: number;
     x_scale_fn: (x: number) => number;
+    x2_scale_fn?: (x: number) => number;
     y_scale_fn: (y: number) => number;
     y2_scale_fn?: (y: number) => number;
     pad: Required<Sides>;
-    x_range: [number, number];
-    y_range: [number, number];
-    y2_range?: [number, number];
+    x_range: Vec2;
+    x2_range?: Vec2;
+    y_range: Vec2;
+    y2_range?: Vec2;
     fullscreen: boolean;
 };
 export type Orientation = `vertical` | `horizontal`;
 export type BarMode = `overlay` | `stacked` | `grouped`;
 export interface BarSeries<Metadata = Record<string, unknown>> {
     id?: string | number;
-    x: readonly number[];
+    x: readonly (number | string)[];
     y: readonly number[];
     label?: string;
     legend_group?: string;
@@ -268,6 +282,7 @@ export interface BarSeries<Metadata = Record<string, unknown>> {
     metadata?: Metadata[] | Metadata;
     labels?: readonly (string | null | undefined)[];
     render_mode?: `bar` | `line`;
+    x_axis?: `x1` | `x2`;
     y_axis?: `y1` | `y2`;
     line_style?: {
         stroke_width?: number;
@@ -295,6 +310,7 @@ export interface AxisOption {
     unit?: string;
 }
 export type Y2SyncMode = `none` | `synced` | `align`;
+export declare function is_y2_sync_mode(val: string): val is Y2SyncMode;
 export interface Y2SyncConfig {
     mode: Y2SyncMode;
     align_value?: number;
@@ -313,6 +329,7 @@ export interface AxisConfig {
     options?: AxisOption[];
     selected_key?: string;
     sync?: Y2SyncConfig | Y2SyncMode;
+    categories?: readonly string[];
 }
 export interface DataLoaderResult<Metadata = Record<string, unknown>, SeriesType = DataSeries<Metadata>> {
     series: SeriesType[];
@@ -331,15 +348,18 @@ export interface ColorScaleOption {
     scale: string | ((t: number) => string);
 }
 export type ColorBarDataLoaderFn = (property_key: string) => Promise<{
-    range: [number, number];
+    range: Vec2;
     title?: string;
 }>;
 export interface DisplayConfig {
     x_grid?: boolean;
+    x2_grid?: boolean;
     y_grid?: boolean;
     y2_grid?: boolean;
     x_zero_line?: boolean;
+    x2_zero_line?: boolean;
     y_zero_line?: boolean;
+    y2_zero_line?: boolean;
 }
 export interface StyleOverrides {
     point?: {
@@ -359,9 +379,10 @@ export interface StyleOverrides {
     show_points?: boolean;
     show_lines?: boolean;
 }
-export type AxisKey = `x` | `y` | `y2`;
+export type AxisKey = `x` | `x2` | `y` | `y2`;
 export interface PlotConfig {
     x_axis?: AxisConfig;
+    x2_axis?: AxisConfig;
     y_axis?: AxisConfig;
     y2_axis?: AxisConfig;
     display?: DisplayConfig;
@@ -388,9 +409,11 @@ export interface PlotControlsProps extends PlotConfig {
     controls_open?: boolean;
     children?: Snippet<[ControlsState]>;
     post_children?: Snippet<[ControlsState]>;
-    auto_x_range?: [number, number];
-    auto_y_range?: [number, number];
-    auto_y2_range?: [number, number];
+    auto_x_range?: Vec2;
+    auto_x2_range?: Vec2;
+    auto_y_range?: Vec2;
+    auto_y2_range?: Vec2;
+    has_x2_points?: boolean;
     has_y2_points?: boolean;
     show_ticks?: boolean;
     controls_title?: string;
@@ -400,6 +423,7 @@ export interface PlotControlsProps extends PlotConfig {
 }
 export interface BasePlotProps {
     x_range?: [number | null, number | null];
+    x2_range?: [number | null, number | null];
     y_range?: [number | null, number | null];
     y2_range?: [number | null, number | null];
     range_padding?: number;
@@ -457,12 +481,12 @@ export type SurfaceType = `grid` | `parametric` | `triangulated`;
 export interface Surface3DConfig {
     id?: string | number;
     type: SurfaceType;
-    x_range?: [number, number];
-    y_range?: [number, number];
-    resolution?: number | [number, number];
+    x_range?: Vec2;
+    y_range?: Vec2;
+    resolution?: number | Vec2;
     z_fn?: (x: number, y: number) => number;
-    u_range?: [number, number];
-    v_range?: [number, number];
+    u_range?: Vec2;
+    v_range?: Vec2;
     parametric_fn?: (u: number, v: number) => XyzObj;
     points?: XyzObj[];
     triangles?: Vec3[];
@@ -541,7 +565,7 @@ export type FillBoundary = {
     value: number;
 } | {
     type: `axis`;
-    axis: `x` | `y` | `y2`;
+    axis: `x` | `x2` | `y` | `y2`;
     value?: number;
 } | {
     type: `function`;
@@ -664,6 +688,7 @@ export interface RefLineBase {
     x_span?: [number | null, number | null];
     y_span?: [number | null, number | null];
     coord_mode?: `data` | `relative`;
+    x_axis?: `x1` | `x2`;
     y_axis?: `y1` | `y2`;
     style?: RefLineStyle;
     annotation?: RefLineAnnotation;
@@ -830,7 +855,7 @@ export interface CleaningQuality {
     oscillation_score?: number;
     bounds_violations: number;
     outliers_removed?: number;
-    stable_range?: [number, number];
+    stable_range?: Vec2;
     truncated_at_x?: number;
 }
 export interface CleaningResult<T = DataSeries> {

package/dist/plot/types.js

@@ -1,3 +1,8 @@
+// Type guard for select value narrowing (avoids unsafe casts)
+const SCALE_TYPE_NAMES = [`linear`, `log`, `arcsinh`, `time`];
+export function is_scale_type_name(val) {
+    return SCALE_TYPE_NAMES.includes(val);
+}
 // Helper to normalize ScaleType to base type name
 export function get_scale_type_name(scale_type) {
     if (!scale_type)
@@ -27,6 +32,11 @@ export function is_time_scale(scale_type, format) {
     // Fallback: d3 time format strings start with '%'
     return format?.startsWith(`%`) ?? false;
 }
+// Type guard for select value narrowing (avoids unsafe casts)
+const Y2_SYNC_MODES = [`none`, `synced`, `align`];
+export function is_y2_sync_mode(val) {
+    return Y2_SYNC_MODES.includes(val);
+}
 export const LINE_TYPES = [`solid`, `dashed`, `dotted`];
 // Define grid cell identifiers
 export const CELLS_3X3 = [

package/dist/plot/utils/label-placement.js

@@ -1,5 +1,6 @@
 import { is_time_scale } from '../types';
 import { forceCollide, forceLink, forceManyBody, forceSimulation } from 'd3-force';
+const is_label_node = (node) => `label_width` in node;
 function parse_font_size(size_str) {
     if (!size_str)
         return 12;
@@ -48,18 +49,20 @@ export function compute_label_positions(filtered_series, config, scales, bounds)
         return Object.fromEntries(label_nodes.map((n) => [n.id, { x: n.x ?? 0, y: n.y ?? 0 }]));
     }
     const sim = forceSimulation([...label_nodes, ...anchor_nodes])
-        .force(`link`, forceLink(links).id((d) => d.id).distance(config.link_distance)
+        .force(`link`, forceLink(links)
+        .id((node) => node.id)
+        .distance(config.link_distance)
         .strength(config.link_strength))
-        .force(`collide`, forceCollide().radius((n) => {
-        const l = n;
-        const a = n;
-        return l.label_width
-            ? Math.sqrt(l.label_width ** 2 + l.label_height ** 2) / 2 + 2
-            : (a.point_radius ?? 0) + 2;
+        .force(`collide`, forceCollide().radius((node) => {
+        if (is_label_node(node)) {
+            return Math.sqrt(node.label_width ** 2 + node.label_height ** 2) / 2 + 2;
+        }
+        return node.point_radius + 2;
     }).strength(config.collision_strength))
-        .force(`charge`, forceManyBody().strength((n) => {
-        const a = n;
-        return a.point_radius !== undefined && a.fx !== undefined
+        .force(`charge`, forceManyBody().strength((node) => {
+        if (is_label_node(node))
+            return 0;
+        return node.point_radius !== undefined && node.fx !== undefined
             ? -(config.charge_strength ?? 50)
             : 0;
     }).distanceMax(config.charge_distance_max ?? 30));
@@ -74,7 +77,7 @@ export function compute_label_positions(filtered_series, config, scales, bounds)
         if (min_dist || max_dist) {
             const dx = x - node.anchor_x;
             const dy = y - node.anchor_y;
-            const dist = Math.sqrt(dx ** 2 + dy ** 2);
+            const dist = Math.hypot(dx, dy);
             if (max_dist && dist > max_dist) {
                 const s = max_dist / dist;
                 x = node.anchor_x + dx * s;

package/dist/plot/utils.d.ts

@@ -0,0 +1 @@
+export declare function calc_auto_range(values: number[]): [number, number];

package/dist/plot/utils.js

@@ -0,0 +1,14 @@
+export function calc_auto_range(values) {
+    const finite_values = values.filter(Number.isFinite);
+    if (finite_values.length === 0)
+        return [0, 1];
+    let [min_value, max_value] = [finite_values[0], finite_values[0]];
+    for (const value of finite_values) {
+        if (value < min_value)
+            min_value = value;
+        else if (value > max_value)
+            max_value = value;
+    }
+    const padding = (max_value - min_value) * 0.05 || 0.5;
+    return [min_value - padding, max_value + padding];
+}

package/dist/rdf/RdfPlot.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">import { PLOT_COLORS } from '../colors';
 import { get_electro_neg_formula } from '../composition';
 import { StatusMessage } from '../feedback';
-import { decompress_file, handle_url_drop } from '../io';
+import { create_file_drop_handler } from '../io';
 import { ScatterPlot } from '../plot';
 import { parse_any_structure } from '../structure/parse';
 import { is_crystal } from '../structure/validation';
@@ -11,47 +11,40 @@ function format_structure_label(struct, label_base) {
     const formula = get_electro_neg_formula(struct);
     return formula && label_base ? `${formula}: ${label_base}` : formula || label_base;
 }
-async function handle_drop(event) {
-    event.preventDefault();
-    dragging = false;
-    if (!enable_drop)
-        return;
-    loading = true;
-    error_msg = undefined;
-    const compute_and_add = (content, filename) => {
-        try {
-            const text = content instanceof ArrayBuffer
-                ? new TextDecoder().decode(content)
-                : content;
-            const parsed_struct = parse_any_structure(text, filename);
-            if (is_crystal(parsed_struct)) {
-                drag_dropped = [...drag_dropped, parsed_struct];
-            }
-            else
-                error_msg = `Crystal has no lattice or sites; cannot compute RDF`;
-        }
-        catch (exc) {
-            error_msg = `Failed to process structure: ${exc instanceof Error ? exc.message : String(exc)}`;
-        }
-    };
+const compute_and_add = (content, filename) => {
     try {
-        const handled = await handle_url_drop(event, on_file_drop || compute_and_add)
-            .catch(() => false);
-        if (handled)
-            return;
-        const file = event.dataTransfer?.files?.[0];
-        if (file) {
-            const { content, filename } = await decompress_file(file);
-            if (content)
-                (on_file_drop || compute_and_add)(content, filename);
+        const text = content instanceof ArrayBuffer
+            ? new TextDecoder().decode(content)
+            : content;
+        const parsed_struct = parse_any_structure(text, filename);
+        if (is_crystal(parsed_struct)) {
+            drag_dropped = [...drag_dropped, parsed_struct];
+        }
+        else {
+            error_msg = `Crystal has no lattice or sites; cannot compute RDF`;
         }
     }
     catch (exc) {
-        error_msg = `Failed to load file: ${exc instanceof Error ? exc.message : String(exc)}`;
-    }
-    finally {
-        loading = false;
+        error_msg = `Failed to process structure: ${exc instanceof Error ? exc.message : String(exc)}`;
     }
+};
+const handle_drop = create_file_drop_handler({
+    allow: () => enable_drop,
+    on_drop: (content, filename) => (on_file_drop || compute_and_add)(content, filename),
+    on_error: (msg) => {
+        error_msg = msg;
+    },
+    set_loading: (val) => {
+        loading = val;
+        if (val)
+            [error_msg, dragging] = [undefined, false];
+    },
+});
+function handle_dragover(ev) {
+    ev.preventDefault();
+    if (ev.dataTransfer)
+        ev.dataTransfer.dropEffect = `copy`;
+    dragging = true;
 }
 const entries = $derived.by(() => {
     const result = [];
@@ -127,11 +120,20 @@ const series = $derived(entries.map((ent, idx) => ({
 {/if}
 
 {#if series.length === 0}
-  <StatusMessage
-    message={enable_drop
-    ? `Drag and drop structure files here to visualize RDFs`
-    : `No RDF data to display`}
-  />
+  <!-- svelte-ignore a11y_no_static_element_interactions -->
+  <div
+    class="empty-drop {dragging ? `dragging` : ``}"
+    ondragover={enable_drop ? handle_dragover : undefined}
+    ondragleave={enable_drop ? () => (dragging = false) : undefined}
+    ondrop={enable_drop ? handle_drop : undefined}
+  >
+    <StatusMessage
+      message={enable_drop
+      ? `Drag and drop structure files here to visualize RDFs`
+      : `No RDF data to display`}
+      style="border: none"
+    />
+  </div>
 {:else}
   <ScatterPlot
     {...rest}
@@ -139,15 +141,9 @@ const series = $derived(entries.map((ent, idx) => ({
     x_axis={{ label: `r (Å)`, range: [0, max_r], ...x_axis }}
     y_axis={{ label: `g(r)`, range: [0, max_g * 1.05], ...y_axis }}
     styles={{ show_lines: true, show_points: false }}
-    class={`${rest.class ?? ``} ${dragging ? `dragging` : ``}`}
+    class="{rest.class ?? ``} {dragging ? `dragging` : ``}"
     style={rest.style ?? `height: 400px;`}
-    ondragover={enable_drop
-    ? (ev) => {
-      ev.preventDefault()
-      if (ev.dataTransfer) ev.dataTransfer.dropEffect = `copy`
-      dragging = true
-    }
-    : undefined}
+    ondragover={enable_drop ? handle_dragover : undefined}
     ondragleave={enable_drop ? () => (dragging = false) : undefined}
     ondrop={enable_drop ? handle_drop : undefined}
   >
@@ -155,22 +151,10 @@ const series = $derived(entries.map((ent, idx) => ({
       {#if show_reference_line}
         {@const y1 = y_scale_fn(1)}
         {#if isFinite(y1)}
-          <line
-            x1={pad.l}
-            x2={width - pad.r}
-            {y1}
-            y2={y1}
-            stroke="gray"
-            stroke-dasharray="4"
-            opacity="0.5"
-          />
-          <text
-            x={width - pad.r - 5}
-            y={y1 - 5}
-            text-anchor="end"
-            fill="gray"
-            font-size="0.8em"
-          >
+          {@const [x1, x2] = [pad.l, width - pad.r]}
+          {@const [x, y] = [width - pad.r - 5, y1 - 5]}
+          <line {x1} {x2} {y1} y2={y1} stroke="gray" stroke-dasharray="4" opacity="0.5" />
+          <text {x} {y} text-anchor="end" fill="gray" font-size="0.8em">
             g(r) = 1
           </text>
         {/if}
@@ -186,6 +170,11 @@ const series = $derived(entries.map((ent, idx) => ({
     outline: 2px dashed #4e79a7;
     outline-offset: 4px;
   }
+  .empty-drop {
+    outline: 2px dashed #ccc;
+    border-radius: var(--border-radius, 3pt);
+    text-align: center;
+  }
   .dropped-info {
     padding: 0.5em;
     margin-bottom: 0.5em;

package/dist/rdf/RdfPlot.svelte.d.ts

@@ -22,6 +22,6 @@ type $$ComponentProps = {
     drag_dropped?: Crystal[];
     dragging?: boolean;
 } & ComponentProps<typeof ScatterPlot>;
-declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "loading" | "error_msg" | "drag_dropped" | "dragging">;
+declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "loading" | "error_msg" | "dragging" | "drag_dropped">;
 type RdfPlot = ReturnType<typeof RdfPlot>;
 export default RdfPlot;

package/dist/rdf/index.d.ts

@@ -1,5 +1,5 @@
 import type { Pbc } from '../structure';
-export { calculate_all_pair_rdfs, calculate_rdf } from './calc-rdf';
+export * from './calc-rdf';
 export { default as RdfPlot } from './RdfPlot.svelte';
 export type RdfPattern = {
     r: number[];

package/dist/rdf/index.js

@@ -1,2 +1,2 @@
-export { calculate_all_pair_rdfs, calculate_rdf } from './calc-rdf';
+export * from './calc-rdf';
 export { default as RdfPlot } from './RdfPlot.svelte';

package/dist/settings.d.ts

@@ -1,4 +1,5 @@
 import type { ColorScaleType, D3InterpolateName } from './colors';
+import type { HullFaceColorMode } from './convex-hull/types';
 import type { D3SymbolName } from './labels';
 import type { Vec3 } from './math';
 import type { Orientation } from './plot';
@@ -49,6 +50,7 @@ type LineStyleType = {
 type SimpleBarStyleType = {
     color: SettingType<string>;
     opacity: SettingType<number>;
+    border_radius: SettingType<number>;
 };
 type SimpleLineStyleType = {
     width: SettingType<number>;
@@ -74,6 +76,7 @@ type ConvexHullWith3DType = ConvexHullCommonType & {
     show_hull_faces: SettingType<boolean>;
     hull_face_color: SettingType<string>;
     hull_face_opacity: SettingType<number>;
+    hull_face_color_mode: SettingType<HullFaceColorMode>;
 };
 export interface SettingsConfig {
     color_scheme: SettingType<string>;
@@ -176,9 +179,11 @@ export interface SettingsConfig {
         show_x_zero_line: SettingType<boolean>;
         show_y_zero_line: SettingType<boolean>;
         show_x_grid: SettingType<boolean>;
+        show_x2_grid: SettingType<boolean>;
         show_y_grid: SettingType<boolean>;
         show_y2_grid: SettingType<boolean>;
         x_format: SettingType<string>;
+        x2_format: SettingType<string>;
         y_format: SettingType<string>;
         y2_format: SettingType<string>;
         x_scale_type: SettingType<string>;