matterviz 0.1.12 → 0.1.13

package/dist/plot/layout.js

@@ -1,4 +1,4 @@
-import { format_value } from './formatting';
+import { format_value } from '../labels';
 // Measure text width using canvas (singleton pattern for performance)
 let measurement_canvas = null;
 export function measure_text_width(text, font = `12px sans-serif`) {
@@ -14,12 +14,24 @@ export function measure_text_width(text, font = `12px sans-serif`) {
     return ctx.measureText(text).width;
 }
 // Helper to measure max tick width
-const measure_max_tick_width = (ticks, format) => ticks.length === 0 ? 0 : Math.max(...ticks.map((tick) => measure_text_width(format_value(tick, format), `12px sans-serif`)));
-export const calc_auto_padding = ({ base_padding, y_ticks = [], y_format = ``, y2_ticks = [], y2_format = ``, label_gap = 45, }) => ({
-    ...base_padding,
-    l: Math.max(base_padding.l, measure_max_tick_width(y_ticks, y_format) + label_gap),
-    r: Math.max(base_padding.r, measure_max_tick_width(y2_ticks, y2_format) + label_gap),
-});
+const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0 ? 0 : Math.max(...ticks.map((tick) => {
+    const label = typeof tick === `string` ? tick : format_value(tick, format);
+    return measure_text_width(label, `12px sans-serif`);
+}));
+export const calc_auto_padding = ({ padding, default_padding, y_axis = {}, y2_axis = {}, label_gap = 45, }) => {
+    const y_ticks = y_axis.tick_values ?? [];
+    const y_format = y_axis.format ?? ``;
+    const y2_ticks = y2_axis.tick_values ?? [];
+    const y2_format = y2_axis.format ?? ``;
+    return {
+        t: padding.t ?? default_padding.t,
+        b: padding.b ?? default_padding.b,
+        l: padding.l ??
+            Math.max(default_padding.l, measure_max_tick_width(y_ticks, y_format) + label_gap),
+        r: padding.r ??
+            Math.max(default_padding.r, measure_max_tick_width(y2_ticks, y2_format) + label_gap),
+    };
+};
 // Constrain tooltip position within chart bounds
 export function constrain_tooltip_position(base_x, base_y, tooltip_width, tooltip_height, chart_width, chart_height) {
     // Calculate the maximum allowable position for the tooltip
@@ -30,10 +42,6 @@ export function constrain_tooltip_position(base_x, base_y, tooltip_width, toolti
         y: Math.min(max_y, Math.max(10, base_y - 10)),
     };
 }
-// Get chart dimensions from width, height, and padding
-export function get_chart_dimensions(width, height, padding) {
-    return { width: width - padding.l - padding.r, height: height - padding.t - padding.b };
-}
 // Define anchor positions with their transform origins
 export const PLACEMENT_ANCHORS = {
     // Corners (priority 1)
@@ -63,12 +71,17 @@ export const PLACEMENT_PRIORITY = [
 export function find_best_plot_area(points, config) {
     const { plot_width, plot_height, padding, margin = 10 } = config;
     const { width = 120, height = 80 } = config.legend_size ?? {};
-    // Detection radius for point counting (legend diagonal / 2)
-    const radius = Math.sqrt(width ** 2 + height ** 2) / 2;
-    const radius_sq = radius * radius;
+    // For performance, subsample points if there are too many (>500)
+    const max_points_for_full_calc = 500;
+    const sampled_points = points.length > max_points_for_full_calc
+        ? (() => {
+            const step = points.length / max_points_for_full_calc;
+            return Array.from({ length: max_points_for_full_calc }, (_, idx) => points[Math.floor(idx * step)]);
+        })()
+        : points;
     let best_position = `top-right`;
-    let min_count = Infinity;
-    // Try each position in priority order, pick the one with fewest nearby points
+    let max_min_distance = -Infinity;
+    // Try each position in priority order, pick the one with maximum distance to nearest point
     for (const position of PLACEMENT_PRIORITY) {
         const { anchor } = PLACEMENT_ANCHORS[position];
         // Calculate position coordinates
@@ -79,20 +92,22 @@ export function find_best_plot_area(points, config) {
             (anchor.x === 0 ? margin : anchor.x === 1 ? -margin : 0);
         const y = base_y +
             (anchor.y === 0 ? margin : anchor.y === 1 ? -margin : 0);
-        // Calculate rectangle center for distance measurement
+        // Calculate legend center for distance measurement
         const center_x = x + width * (0.5 - anchor.x);
         const center_y = y + height * (0.5 - anchor.y);
-        // Count nearby points
-        let count = 0;
-        for (const point of points) {
+        // Find minimum distance to any point (distance to nearest point)
+        let min_distance_sq = Infinity;
+        for (const point of sampled_points) {
             const dx = point.x - center_x;
             const dy = point.y - center_y;
-            if (dx * dx + dy * dy <= radius_sq)
-                count++;
+            const dist_sq = dx * dx + dy * dy;
+            if (dist_sq < min_distance_sq) {
+                min_distance_sq = dist_sq;
+            }
         }
-        // Update best if this position is less crowded
-        if (count < min_count) {
-            min_count = count;
+        // Update best if this position has greater distance to nearest point
+        if (min_distance_sq > max_min_distance) {
+            max_min_distance = min_distance_sq;
             best_position = position;
         }
     }

package/dist/plot/scales.d.ts

@@ -1,16 +1,15 @@
-import type { Point } from './';
-import type { ScaleContinuousNumeric } from 'd3-scale';
-export type ScaleType = `linear` | `log`;
-export type TimeInterval = `day` | `month` | `year`;
-export type TicksOption = number | number[] | TimeInterval;
+import type { Point, ScaleType, TimeInterval } from './';
+import type { ScaleContinuousNumeric, ScaleTime } from 'd3-scale';
+export type TicksOption = number | number[] | TimeInterval | Record<number, string>;
 export declare function create_scale(scale_type: ScaleType, domain: [number, number], range: [number, number]): import("d3-scale").ScaleLinear<number, number, never>;
-export declare function create_time_scale(domain: [number, number], range: [number, number]): import("d3-scale").ScaleTime<number, number, never>;
-export declare function generate_ticks(domain: [number, number], scale_type: ScaleType, ticks_option: TicksOption | undefined, scale_fn: ScaleContinuousNumeric<number, number>, // D3 scale function with .ticks() method
+export declare function create_time_scale(domain: [number, number], range: [number, number]): ScaleTime<number, number, never>;
+export declare function generate_ticks(domain: [number, number], scale_type: ScaleType, ticks_option: TicksOption | undefined, scale_fn: ScaleContinuousNumeric<number, number> | ScaleTime<number, number>, // D3 scale function with .ticks() method
 options?: {
     format?: string;
     default_count?: number;
     interval_padding?: number;
 }): number[];
 export declare function calculate_domain(values: number[], scale_type?: ScaleType): [number, number];
-export declare function get_nice_data_range(points: Point[], get_value: (p: Point) => number, lim: [number | null, number | null], scale_type: ScaleType, padding_factor: number, is_time?: boolean): [number, number];
+export declare function get_nice_data_range(points: Point[], get_value: (p: Point) => number, range: [number | null, number | null], scale_type: ScaleType, padding_factor: number, is_time?: boolean): [number, number];
 export declare function generate_log_ticks(min: number, max: number, ticks_option?: TicksOption): number[];
+export declare function get_tick_label(tick_value: number, ticks_option: TicksOption | undefined): string | null;

package/dist/plot/scales.js

@@ -19,6 +19,14 @@ export function generate_ticks(domain, scale_type, ticks_option, scale_fn, // D3
 options = {}) {
     const { format, default_count = 8, interval_padding = 0.1 } = options;
     const [min_val, max_val] = domain;
+    // If ticks_option is an object (value-to-label mapping), extract values
+    if (ticks_option && typeof ticks_option === `object` && !Array.isArray(ticks_option)) {
+        const [domain_min, domain_max] = [Math.min(...domain), Math.max(...domain)];
+        return Object.keys(ticks_option)
+            .map(Number)
+            .filter((val) => Number.isFinite(val) && val >= domain_min && val <= domain_max)
+            .sort((a, b) => a - b);
+    }
     // If ticks_option is already an array, use it directly
     if (Array.isArray(ticks_option))
         return ticks_option;
@@ -73,13 +81,13 @@ export function calculate_domain(values, scale_type = `linear`) {
         : [min_val, max_val];
 }
 // Advanced domain calculation with padding and nice boundaries (from ScatterPlot)
-export function get_nice_data_range(points, get_value, lim, scale_type, padding_factor, is_time = false) {
-    const [min_lim, max_lim] = lim;
+export function get_nice_data_range(points, get_value, range, scale_type, padding_factor, is_time = false) {
+    const [min, max] = range;
     const [min_ext, max_ext] = extent(points, get_value);
-    let data_min = min_lim ?? min_ext ?? 0;
-    let data_max = max_lim ?? max_ext ?? 1;
+    let data_min = min ?? min_ext ?? 0;
+    let data_max = max ?? max_ext ?? 1;
     // Apply padding *only if* limits were NOT provided
-    if (min_lim === null && max_lim === null && points.length > 0) {
+    if (min === null && max === null && points.length > 0) {
         if (data_min !== data_max) {
             // Apply percentage padding based on scale type if there's a range
             const span = data_max - data_min;
@@ -163,7 +171,14 @@ export function generate_log_ticks(min, max, ticks_option) {
             if (power * 5 <= Math.pow(10, extended_max_power))
                 detailed_ticks.push(power * 5);
         });
-        return detailed_ticks;
+        return detailed_ticks.filter((t) => t >= min && t <= max);
+    }
+    return powers.filter((p) => p >= min && p <= max);
+}
+// Get custom label for a tick value if provided, otherwise return null
+export function get_tick_label(tick_value, ticks_option) {
+    if (ticks_option && typeof ticks_option === `object` && !Array.isArray(ticks_option)) {
+        return ticks_option[tick_value] ?? null;
     }
-    return powers;
+    return null;
 }

package/dist/plot/types.d.ts

@@ -0,0 +1,303 @@
+import type DraggablePane from '../DraggablePane.svelte';
+import type { D3SymbolName } from '../labels';
+import type { SimulationNodeDatum } from 'd3-force';
+import type { ComponentProps, Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import type ColorBar from './ColorBar.svelte';
+import type PlotLegend from './PlotLegend.svelte';
+import type { TicksOption } from './scales';
+export interface TweenedOptions<T> {
+    delay?: number;
+    duration?: number | ((from: T, to: T) => number);
+    easing?: (t: number) => number;
+    interpolate?: (a: T, b: T) => (t: number) => T;
+}
+export type XyObj = {
+    x: number;
+    y: number;
+};
+export type Sides = {
+    t?: number;
+    b?: number;
+    l?: number;
+    r?: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    offset?: XyObj;
+};
+export interface PointStyle {
+    fill?: string;
+    radius?: number;
+    stroke?: string;
+    stroke_width?: number;
+    stroke_opacity?: number;
+    fill_opacity?: number;
+    symbol_type?: D3SymbolName;
+    symbol_size?: number | null;
+    shape?: string;
+    cursor?: string;
+}
+export interface HoverStyle {
+    enabled?: boolean;
+    scale?: number;
+    stroke?: string;
+    stroke_width?: number;
+    brightness?: number;
+}
+export interface LabelStyle {
+    text?: string;
+    offset?: XyObj;
+    font_size?: string;
+    font_family?: string;
+    auto_placement?: boolean;
+}
+export interface BarStyle {
+    color?: string;
+    opacity?: number;
+    stroke_width?: number;
+    stroke_color?: string;
+    stroke_opacity?: number;
+    [key: string]: unknown;
+}
+export interface LineStyle {
+    color?: string;
+    width?: number;
+    dash?: string;
+    [key: string]: unknown;
+}
+export interface PlotPoint extends Point {
+    color_value?: number | null;
+    metadata?: Record<string, unknown>;
+    point_style?: PointStyle;
+    point_hover?: HoverStyle;
+    point_label?: LabelStyle;
+    point_offset?: XyObj;
+    point_tween?: TweenedOptions<XyObj>;
+}
+export type Markers = `line` | `points` | `line+points` | `none`;
+export interface DataSeries {
+    id?: string | number;
+    x: readonly number[];
+    y: readonly number[];
+    markers?: Markers;
+    y_axis?: `y1` | `y2`;
+    color_values?: (number | null)[] | null;
+    size_values?: readonly (number | null)[] | null;
+    metadata?: Record<string, unknown>[] | Record<string, unknown>;
+    point_style?: PointStyle[] | PointStyle;
+    point_hover?: HoverStyle[] | HoverStyle;
+    point_label?: LabelStyle[] | LabelStyle;
+    point_offset?: XyObj[] | XyObj;
+    point_tween?: TweenedOptions<XyObj>;
+    visible?: boolean;
+    label?: string;
+    unit?: string;
+    line_style?: {
+        stroke?: string;
+        stroke_width?: number;
+        line_dash?: string;
+    };
+}
+export interface InternalPoint extends PlotPoint {
+    series_idx: number;
+    point_idx: number;
+    size_value?: number | null;
+}
+export interface Tooltip {
+    show: boolean;
+    x: number;
+    y: number;
+    title?: string;
+    items?: {
+        label: string;
+        value: string;
+        color?: string;
+    }[];
+}
+export interface TooltipProps {
+    x: number;
+    y: number;
+    metadata?: Record<string, unknown> | null;
+    color?: string | null;
+    label?: string | null;
+    series_idx: number;
+}
+export interface ScatterTooltipProps extends TooltipProps {
+    cx: number;
+    cy: number;
+    x_formatted: string;
+    y_formatted: string;
+}
+export interface BarTooltipProps extends TooltipProps {
+    bar_idx: number;
+    orient_x: number;
+    orient_y: number;
+    y_axis: `y1` | `y2`;
+}
+export type TimeInterval = `day` | `month` | `year`;
+export type ScaleType = `linear` | `log`;
+export type QuadrantCounts = {
+    top_left: number;
+    top_right: number;
+    bottom_left: number;
+    bottom_right: number;
+};
+export interface LabelNode extends SimulationNodeDatum {
+    id: string;
+    anchor_x: number;
+    anchor_y: number;
+    point_node: InternalPoint;
+    label_width: number;
+    label_height: number;
+}
+export interface LabelPlacementConfig {
+    collision_strength: number;
+    link_strength: number;
+    link_distance: number;
+    placement_ticks: number;
+    link_distance_range?: [number | null, number | null];
+}
+export type HoverConfig = {
+    threshold_px: number;
+};
+export interface AnchorNode extends SimulationNodeDatum {
+    id: string;
+    fx: number;
+    fy: number;
+    point_radius: number;
+    show_color_bar?: boolean;
+    color_bar?: ComponentProps<typeof ColorBar> | null;
+    label_placement_config?: Partial<LabelPlacementConfig>;
+}
+export type LegendConfig = Omit<ComponentProps<typeof PlotLegend>, `series_data` | `on_drag_start` | `on_drag` | `on_drag_end`> & {
+    margin?: number | Sides;
+    tween?: TweenedOptions<XyObj>;
+    responsive?: boolean;
+    draggable?: boolean;
+};
+export interface LegendItem {
+    label: string;
+    visible: boolean;
+    series_idx: number;
+    display_style: {
+        symbol_type?: D3SymbolName;
+        symbol_color?: string;
+        line_color?: string;
+        line_dash?: string;
+    };
+}
+export type UserContentProps = {
+    height: number;
+    width: number;
+    x_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];
+};
+export type Orientation = `vertical` | `horizontal`;
+export type BarMode = `overlay` | `stacked` | `grouped`;
+export interface BarSeries {
+    id?: string | number;
+    x: readonly number[];
+    y: readonly number[];
+    label?: string;
+    color?: string;
+    bar_width?: number | readonly number[];
+    visible?: boolean;
+    metadata?: Record<string, unknown>[] | Record<string, unknown>;
+    labels?: readonly (string | null | undefined)[];
+    render_mode?: `bar` | `line`;
+    y_axis?: `y1` | `y2`;
+    line_style?: {
+        stroke_width?: number;
+        line_dash?: string;
+    };
+}
+export interface AxisConfig {
+    label?: string;
+    format?: string;
+    ticks?: TicksOption;
+    scale_type?: ScaleType;
+    range?: [number | null, number | null];
+    unit?: string;
+    label_shift?: {
+        x?: number;
+        y?: number;
+    };
+    tick_label_shift?: {
+        x?: number;
+        y?: number;
+    };
+    tick_rotation?: number;
+    grid_style?: HTMLAttributes<SVGLineElement>;
+    color?: string | null;
+}
+export interface DisplayConfig {
+    x_grid?: boolean;
+    y_grid?: boolean;
+    y2_grid?: boolean;
+    x_zero_line?: boolean;
+    y_zero_line?: boolean;
+}
+export interface StyleOverrides {
+    point?: {
+        size?: number;
+        color?: string;
+        opacity?: number;
+        stroke_width?: number;
+        stroke_color?: string;
+        stroke_opacity?: number;
+    };
+    line?: {
+        width?: number;
+        color?: string;
+        opacity?: number;
+        dash?: string;
+    };
+    show_points?: boolean;
+    show_lines?: boolean;
+}
+export interface ControlsConfig {
+    show?: boolean;
+    open?: boolean;
+    toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
+    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+}
+export interface PlotControlsProps {
+    show_controls?: boolean;
+    controls_open?: boolean;
+    children?: Snippet<[]>;
+    post_children?: Snippet<[]>;
+    x_axis?: AxisConfig;
+    y_axis?: AxisConfig;
+    y2_axis?: AxisConfig;
+    display?: DisplayConfig;
+    auto_x_range?: [number, number];
+    auto_y_range?: [number, number];
+    auto_y2_range?: [number, number];
+    has_y2_points?: boolean;
+    show_ticks?: boolean;
+    controls_title?: string;
+    controls_class?: string;
+    toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
+    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+}
+export interface BasePlotProps {
+    x_range?: [number | null, number | null];
+    y_range?: [number | null, number | null];
+    y2_range?: [number | null, number | null];
+    range_padding?: number;
+    padding?: Sides;
+    change?: (...args: unknown[]) => void;
+    controls_toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
+    controls_pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+    children?: Snippet<[]>;
+}

package/dist/plot/types.js

@@ -0,0 +1 @@
+export {};

package/dist/rdf/RdfPlot.svelte

@@ -0,0 +1,156 @@
+<script lang="ts">import { plot_colors } from '../colors';
+import { get_electro_neg_formula } from '../composition';
+import { ScatterPlot } from '../plot';
+import { calculate_all_pair_rdfs, calculate_rdf } from './index';
+let { patterns, structures, mode = `element_pairs`, show_reference_line = true, x_axis = {}, y_axis = {}, cutoff = 15, n_bins = 75, pbc = [true, true, true], enable_drop = false, children, ...rest } = $props();
+// Set default axis labels if not provided
+x_axis.label ??= `r (Å)`;
+y_axis.label ??= `g(r)`;
+let dropped = $state([]);
+let dragging = $state(false);
+const entries = $derived.by(() => {
+    const result = [];
+    // Add patterns
+    if (patterns) {
+        if (Array.isArray(patterns))
+            result.push(...patterns);
+        else
+            result.push(patterns);
+    }
+    // Add structures
+    const struct_list = [];
+    if (structures) {
+        if (Array.isArray(structures)) {
+            structures.forEach((struct, idx) => struct_list.push({ struct: struct, label: `Structure ${idx + 1}` }));
+        }
+        else if (`lattice` in structures && `sites` in structures) {
+            struct_list.push({
+                struct: structures,
+                label: `${get_electro_neg_formula(structures)}: `,
+            });
+        }
+        else {
+            Object.entries(structures).forEach(([label, struct]) => struct_list.push({ struct, label }));
+        }
+    }
+    dropped.forEach((struct, idx) => struct_list.push({ struct, label: `Dropped ${idx + 1}` }));
+    for (const { struct, label } of struct_list) {
+        if (mode === `element_pairs`) {
+            const pairs = calculate_all_pair_rdfs(struct, { cutoff, n_bins, pbc });
+            result.push(...pairs.map((p) => ({
+                label: p.element_pair
+                    ? `${label} ${p.element_pair[0]}-${p.element_pair[1]}`
+                    : label,
+                pattern: p,
+            })));
+        }
+        else { // Calculate full RDF directly without element filters to properly weight all pairs
+            const full_rdf = calculate_rdf(struct, { cutoff, n_bins, pbc });
+            result.push({ label, pattern: full_rdf });
+        }
+    }
+    return result;
+});
+const max_r = $derived(Math.max(...entries.flatMap((e) => e.pattern.r), 0));
+const max_g = $derived(Math.max(1.2, ...entries.flatMap((e) => e.pattern.g_r)));
+const series = $derived(entries.map((ent, idx) => ({
+    x: ent.pattern.r,
+    y: ent.pattern.g_r,
+    label: ent.label,
+    visible: true,
+    markers: `line`,
+    line_style: {
+        stroke: ent.color ?? plot_colors[idx % plot_colors.length],
+        stroke_width: 2,
+    },
+})));
+async function handle_drop(ev) {
+    ev.preventDefault();
+    dragging = false;
+    const files = ev.dataTransfer?.files;
+    if (!files)
+        return;
+    for (const file of Array.from(files)) {
+        try {
+            const struct = JSON.parse(await file.text());
+            if (struct.lattice && struct.sites)
+                dropped = [...dropped, struct];
+        }
+        catch { }
+    }
+}
+</script>
+
+{#if enable_drop && dropped.length > 0}
+  <div
+    style="padding: 0.5em; margin-bottom: 0.5em; background: #f0f0f0; border-radius: 4px"
+  >
+    {dropped.length} structure{dropped.length > 1 ? `s` : ``} loaded
+    <button onclick={() => (dropped = [])}>Clear</button>
+  </div>
+{/if}
+
+<ScatterPlot
+  {...rest}
+  {series}
+  x_axis={{ ...x_axis, range: [0, max_r] }}
+  y_axis={{ ...y_axis, range: [0, max_g * 1.05] }}
+  styles={{ show_lines: true, show_points: false }}
+  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}
+  ondragleave={enable_drop ? () => (dragging = false) : undefined}
+  ondrop={enable_drop ? handle_drop : undefined}
+>
+  {#snippet user_content({ width, y_scale_fn, pad })}
+    {#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"
+        >
+          g(r) = 1
+        </text>
+      {/if}
+    {/if}
+  {/snippet}
+
+  {@render children?.()}
+</ScatterPlot>
+
+<style>
+  :global(.dragging) {
+    outline: 2px dashed #4e79a7;
+    outline-offset: 4px;
+  }
+  button {
+    margin-left: 1em;
+    padding: 0.25em 0.75em;
+    background: #e0e0e0;
+    border: 1px solid #ccc;
+    border-radius: 3px;
+    cursor: pointer;
+  }
+  button:hover {
+    background: #d0d0d0;
+  }
+</style>

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

@@ -0,0 +1,20 @@
+import { ScatterPlot } from '../plot';
+import type { Pbc, PymatgenStructure as Structure } from '../structure';
+import type { ComponentProps, Snippet } from 'svelte';
+import { type RdfEntry } from './index';
+type $$ComponentProps = {
+    patterns?: RdfEntry | RdfEntry[];
+    structures?: Structure | Structure[] | Record<string, Structure>;
+    mode?: `element_pairs` | `full`;
+    show_reference_line?: boolean;
+    x_axis?: ComponentProps<typeof ScatterPlot>[`x_axis`];
+    y_axis?: ComponentProps<typeof ScatterPlot>[`y_axis`];
+    cutoff?: number;
+    n_bins?: number;
+    pbc?: Pbc;
+    enable_drop?: boolean;
+    children?: Snippet<[]>;
+} & ComponentProps<typeof ScatterPlot>;
+declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "">;
+type RdfPlot = ReturnType<typeof RdfPlot>;
+export default RdfPlot;

package/dist/rdf/calc-rdf.d.ts

@@ -0,0 +1,4 @@
+import type { PymatgenStructure as Structure } from '../structure';
+import type { RdfOptions, RdfPattern } from './index';
+export declare function calculate_rdf(structure: Structure, options?: RdfOptions): RdfPattern;
+export declare function calculate_all_pair_rdfs(structure: Structure, options?: Omit<RdfOptions, `center_species` | `neighbor_species`>): RdfPattern[];