matterviz 0.3.6 → 0.4.0

package/dist/plot/sunburst/sunburst.js

@@ -0,0 +1,266 @@
+// Layout helpers for Sunburst charts, wrapping d3-hierarchy's partition.
+// Single source of truth for the hierarchy/angle math so the component stays
+// declarative and the layout is independently unit-testable. The partition is
+// computed in normalized coordinates (angle as fraction of full circle in [0, 1],
+// radius in integer ring units where y0 === depth) independent of pixel size and
+// zoom — the component maps these to screen space per frame (zoomable-sunburst trick).
+import { hsl } from 'd3-color';
+import { hierarchy, partition } from 'd3-hierarchy';
+import { DEFAULT_SERIES_COLORS } from '../core/types';
+// Compute normalized arc extents, resolved colors and breadcrumbs for a node tree.
+// Never mutates user data: d3-hierarchy wraps inputs in HierarchyNodes and all derived
+// fields (value overrides, ids, colors) are written onto the returned arcs only.
+export function compute_sunburst_layout(data, opts = {}) {
+    const { value_mode = `leaf-sum`, sort = `none`, level_lighten = 0, min_fraction = 0, other_label = `Other`, } = opts;
+    // Fresh object each call (not a shared constant) so callers can't corrupt each other
+    if (Array.isArray(data) ? data.length === 0 : !data) {
+        return { arcs: [], root: null, max_depth: 0 };
+    }
+    // Single root node is used directly; arrays get a synthetic invisible root
+    const root_data = Array.isArray(data) ? { children: data } : data;
+    const root = hierarchy(root_data, (node) => node.children);
+    // 'remainder': d3's .sum() adds the node's own value on top of its children's sum,
+    // which is exactly plotly's branchvalues='remainder'. 'leaf-sum' ignores parent values.
+    // 'total': every explicitly set value is authoritative (plotly branchvalues='total');
+    // nodes without one get their children's sum. Children summing to less than their
+    // parent leave a trailing angular gap; more than the parent overflows (plotly errors
+    // here; we warn and the component clamps angles).
+    if (value_mode === `remainder`)
+        root.sum((node) => node.value ?? 0);
+    else if (value_mode === `total`) {
+        root.eachAfter((node) => {
+            const child_sum = node.children?.reduce((sum, child) => sum + (child.value ?? 0), 0) ?? 0;
+            node.value = node.data.value ?? child_sum;
+            if (node.children && node.data.value != null && child_sum > node.data.value + 1e-9) {
+                console.warn(`Sunburst: children of "${node.data.label ?? node.data.id ?? `root`}" sum to ${child_sum}, exceeding its value of ${node.data.value} (value_mode='total')`);
+            }
+        });
+    }
+    else
+        root.sum((node) => (node.children?.length ? 0 : (node.value ?? 0)));
+    if (sort !== `none`) {
+        const sign = sort === `descending` ? -1 : 1;
+        root.sort((node_a, node_b) => sign * ((node_a.value ?? 0) - (node_b.value ?? 0)));
+    }
+    // 'Other' bucketing: move sub-threshold children to the end of each sibling list
+    // (after sorting, before partition) so the smalls occupy one contiguous angular run
+    // that flatten() below can merge into a single synthetic arc.
+    const bucket_threshold = min_fraction > 0 ? min_fraction * (root.value ?? 0) : 0;
+    if (bucket_threshold > 0) {
+        root.each((node) => {
+            if (!node.children)
+                return;
+            const small = node.children.filter((child) => (child.value ?? 0) < bucket_threshold);
+            if (small.length >= 2) {
+                const kept = node.children.filter((child) => (child.value ?? 0) >= bucket_threshold);
+                node.children = [...kept, ...small];
+            }
+        });
+    }
+    // x in [0, 1] (angle fraction), y in ring units (y0 === depth, y1 === depth + 1)
+    const part_root = partition().size([1, root.height + 1])(root);
+    const arcs = [];
+    const seen_ids = new Set();
+    const root_value = root.value ?? 0;
+    const palette_len = DEFAULT_SERIES_COLORS.length;
+    let depth1_count = 0; // running index among depth-1 nodes, for palette cycling
+    // Resolved fill for a node: explicit > depth-1 palette > inherited, optionally
+    // lightened by depth. base = unlightened color descendants inherit.
+    const resolve_color = (depth, explicit, parent_base) => {
+        const base = explicit ??
+            (depth === 1
+                ? DEFAULT_SERIES_COLORS[depth1_count++ % palette_len]
+                : (parent_base ?? `transparent`));
+        let color = base;
+        if (!explicit && depth > 1 && level_lighten > 0) {
+            color = hsl(base)
+                .brighter(level_lighten * (depth - 1))
+                .formatHex();
+        }
+        return { base, color };
+    };
+    // Construct + append an arc, deriving indices, breadcrumbs and fractions from the
+    // parent (shared by regular nodes and synthetic 'Other' arcs)
+    const push_arc = (parent, fields) => {
+        if (seen_ids.has(fields.id)) {
+            console.warn(`Sunburst: duplicate node id "${fields.id}" — set unique \`id\`s or labels.`);
+        }
+        seen_ids.add(fields.id);
+        const arc = {
+            node_idx: arcs.length,
+            subtree_end: arcs.length, // leaves keep this; branches update after recursion
+            parent_idx: parent?.node_idx ?? null,
+            path: parent ? [...parent.path, fields.id] : [],
+            label_path: parent ? [...parent.label_path, fields.label ?? `${fields.id}`] : [],
+            fraction: root_value > 0 ? fields.value / root_value : 0,
+            parent_fraction: parent ? (parent.value > 0 ? fields.value / parent.value : 0) : 1,
+            ...fields,
+        };
+        arcs.push(arc);
+        return arc;
+    };
+    // Pre-order DFS so each subtree occupies a contiguous node_idx range
+    const flatten = (node, parent, parent_base, // unlightened color descendants inherit
+    child_idx) => {
+        const { depth } = node;
+        const explicit = node.data.color;
+        const { base, color } = resolve_color(depth, explicit, parent_base);
+        // Stable id: explicit, else slash-joined label path (e.g. "cubic/Fm-3m")
+        const parent_prefix = parent && parent.id !== `` ? `${parent.id}/` : ``;
+        const segment = node.data.label ?? `${child_idx}`;
+        const id = node.data.id ?? (depth === 0 ? (node.data.label ?? ``) : `${parent_prefix}${segment}`);
+        const { x0, x1, y0, y1 } = node;
+        const arc = push_arc(parent, {
+            id,
+            label: node.data.label,
+            value: node.value ?? 0,
+            color,
+            depth,
+            is_leaf: !node.children?.length,
+            x0,
+            x1,
+            y0,
+            y1,
+            metadata: node.data.metadata,
+        });
+        // Children below the bucket threshold form a contiguous trailing run (reordered
+        // above); merge runs of >= 2 into one synthetic 'Other' leaf instead of recursing
+        const kids = node.children ?? [];
+        let cut = kids.length;
+        if (bucket_threshold > 0) {
+            const first_small = kids.findLastIndex((kid) => (kid.value ?? 0) >= bucket_threshold) + 1;
+            if (kids.length - first_small >= 2)
+                cut = first_small;
+        }
+        kids.forEach((child, idx) => {
+            if (idx < cut)
+                flatten(child, arc, explicit ?? base, idx);
+        });
+        if (cut < kids.length) {
+            const smalls = kids.slice(cut);
+            push_arc(arc, {
+                id: `${arc.id !== `` ? `${arc.id}/` : ``}${other_label}`,
+                label: other_label,
+                value: smalls.reduce((sum, child) => sum + (child.value ?? 0), 0),
+                color: resolve_color(depth + 1, undefined, explicit ?? base).color,
+                depth: depth + 1,
+                is_leaf: true,
+                is_other: true,
+                x0: smalls[0].x0,
+                x1: smalls[smalls.length - 1].x1,
+                y0: depth + 1,
+                y1: depth + 2,
+            });
+        }
+        arc.subtree_end = arcs.length - 1;
+    };
+    flatten(part_root, null, null, 0);
+    return { arcs, root: arcs[0], max_depth: root.height };
+}
+// Build a nested node tree from flat path rows (plotly-express style), e.g.
+// { path: ['cubic', 'Fm-3m'], value: 12 }. Rows sharing a full path accumulate their
+// values; rows whose path is a proper prefix of others set that interior node's own
+// value (meaningful with value_mode 'total'/'remainder').
+export function sunburst_from_paths(rows) {
+    const roots = new Map();
+    rows.forEach((row, row_idx) => {
+        if (!row.path || row.path.length === 0) {
+            throw new Error(`sunburst_from_paths: row ${row_idx} has an empty path`);
+        }
+        let level = roots;
+        let trie;
+        let id = ``;
+        for (const segment of row.path) {
+            id = id ? `${id}/${segment}` : `${segment}`;
+            trie = level.get(segment);
+            if (!trie) {
+                trie = { node: { id, label: `${segment}` }, children: new Map() };
+                level.set(segment, trie);
+            }
+            level = trie.children;
+        }
+        const node = trie.node;
+        node.value = (node.value ?? 0) + row.value;
+        if (row.color != null)
+            node.color = row.color;
+        if (row.metadata != null)
+            node.metadata = row.metadata;
+    });
+    const to_nodes = (level) => [...level.values()].map(({ node, children }) => children.size ? { ...node, children: to_nodes(children) } : node);
+    return to_nodes(roots);
+}
+// Build a nested node tree from plotly trace arrays (labels/parents/values [+ ids]),
+// the format pymatviz/matbench-discovery sunburst exports use (with branchvalues
+// 'total' -> pair with value_mode 'total'). parents entries of ''/null/undefined mark
+// root-level nodes; parents reference ids when given, else labels.
+export function sunburst_from_labels_parents(labels, parents, values, opts = {}) {
+    const { ids, colors, metadata } = opts;
+    for (const [name, arr] of [
+        [`parents`, parents],
+        [`values`, values],
+        [`ids`, ids],
+        [`colors`, colors],
+        [`metadata`, metadata],
+    ]) {
+        if (arr && arr.length !== labels.length) {
+            throw new Error(`sunburst_from_labels_parents: labels (${labels.length}) and ${name} (${arr.length}) must have equal length`);
+        }
+    }
+    const key_to_idx = new Map();
+    const nodes = labels.map((label, idx) => {
+        const key = ids?.[idx] ?? label;
+        if (key_to_idx.has(key)) {
+            throw new Error(`sunburst_from_labels_parents: duplicate node ${ids ? `id` : `label`} "${key}"${ids ? `` : ` — pass opts.ids to disambiguate`}`);
+        }
+        key_to_idx.set(key, idx);
+        const node = { id: key, label };
+        if (values?.[idx] != null)
+            node.value = values[idx];
+        if (colors?.[idx] != null)
+            node.color = colors[idx];
+        if (metadata?.[idx] != null)
+            node.metadata = metadata[idx];
+        return node;
+    });
+    // Resolve all parent references up front (one map lookup per node)
+    const parent_idxs = labels.map((_, idx) => {
+        const ref = parents[idx];
+        if (ref == null || ref === ``)
+            return null;
+        const found = key_to_idx.get(ref);
+        if (found === undefined) {
+            throw new Error(`sunburst_from_labels_parents: node "${ids?.[idx] ?? labels[idx]}" references unknown parent "${ref}"`);
+        }
+        return found;
+    });
+    // O(n) cycle detection: walk each unvisited parent chain once, marking nodes
+    // 'in-progress' on the way up. Hitting an in-progress node = cycle; hitting a
+    // 'done' node = chain already verified acyclic.
+    const state = new Uint8Array(nodes.length); // 0 = unvisited, 1 = in progress, 2 = done
+    for (let idx = 0; idx < nodes.length; idx++) {
+        if (state[idx] !== 0)
+            continue;
+        let cur = idx;
+        while (cur != null && state[cur] === 0) {
+            state[cur] = 1;
+            cur = parent_idxs[cur];
+        }
+        if (cur != null && state[cur] === 1) {
+            throw new Error(`sunburst_from_labels_parents: cycle detected involving node "${ids?.[cur] ?? labels[cur]}"`);
+        }
+        // Mark the walked chain as verified
+        for (let mark = idx; mark != null && state[mark] === 1;) {
+            state[mark] = 2;
+            mark = parent_idxs[mark];
+        }
+    }
+    const roots = [];
+    nodes.forEach((node, idx) => {
+        const parent = parent_idxs[idx];
+        if (parent == null)
+            roots.push(node);
+        else
+            (nodes[parent].children ??= []).push(node);
+    });
+    return roots;
+}

package/dist/rdf/RdfPlot.svelte

@@ -0,0 +1,248 @@
+<script lang="ts">
+  import { PLOT_COLORS } from '../colors'
+  import { get_electro_neg_formula } from '../composition'
+  import { StatusMessage } from '../feedback'
+  import { create_file_drop_handler } from '../io'
+  import type { DataSeries } from '../plot'
+  import { ScatterPlot } from '../plot'
+  import type { Crystal, Pbc } from '../structure'
+  import { parse_any_structure } from '../structure/parse'
+  import { is_crystal } from '../structure/validation'
+  import type { ComponentProps, Snippet } from 'svelte'
+  import { calculate_all_pair_rdfs, calculate_rdf, type RdfEntry } from './index'
+  import { to_error } from '../utils'
+
+  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,
+    on_file_drop,
+    loading = $bindable(false),
+    error_msg = $bindable(),
+    children,
+    drag_dropped = $bindable([]),
+    dragging = $bindable(false),
+    ...rest
+  }: {
+    patterns?: RdfEntry | RdfEntry[]
+    structures?: Crystal | Crystal[] | Record<string, Crystal>
+    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
+    on_file_drop?: (content: string | ArrayBuffer, filename: string) => void
+    loading?: boolean
+    error_msg?: string
+    children?: Snippet<[{ drag_dropped: Crystal[] }]>
+    drag_dropped?: Crystal[]
+    dragging?: boolean
+  } & ComponentProps<typeof ScatterPlot> = $props()
+
+  function format_structure_label(struct: Crystal, label_base: string): string {
+    const formula = get_electro_neg_formula(struct)
+    return formula && label_base ? `${formula}: ${label_base}` : formula || label_base
+  }
+
+  const compute_and_add = (content: string | ArrayBuffer, filename: string) => {
+    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: ${
+        to_error(exc).message
+      }`
+    }
+  }
+
+  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: DragEvent) {
+    ev.preventDefault()
+    if (ev.dataTransfer) ev.dataTransfer.dropEffect = `copy`
+    dragging = true
+  }
+
+  const entries = $derived.by(() => {
+    const result: RdfEntry[] = []
+
+    // Add patterns
+    if (patterns) {
+      if (Array.isArray(patterns)) result.push(...patterns)
+      else result.push(patterns)
+    }
+
+    // Add structures
+    const struct_list: { struct: Crystal; label: string }[] = []
+    if (structures) {
+      if (Array.isArray(structures)) {
+        structures.forEach((struct, idx) =>
+          struct_list.push({
+            struct,
+            label: format_structure_label(struct, `Crystal ${idx + 1}`),
+          })
+        )
+      } else if (is_crystal(structures)) {
+        struct_list.push({
+          struct: structures,
+          label: format_structure_label(structures, ``),
+        })
+      } else {
+        Object.entries(structures).forEach(([label, struct]) =>
+          struct_list.push({ struct, label: format_structure_label(struct, label) })
+        )
+      }
+    }
+    drag_dropped.forEach((struct, idx) =>
+      struct_list.push({
+        struct,
+        label: format_structure_label(struct, `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((pair) => ({
+          label: pair.element_pair ? `${pair.element_pair[0]}-${pair.element_pair[1]}` : label,
+          legend_group: label, // Group by structure name for multi-structure plots
+          pattern: pair,
+        })))
+      } else {
+        const pattern = calculate_rdf(struct, { cutoff, n_bins, pbc })
+        result.push({ label, pattern })
+      }
+    }
+    return result
+  })
+
+  const max_r = $derived(Math.max(...entries.flatMap((entry) => entry.pattern.r), 0))
+  const max_g = $derived(Math.max(1.2, ...entries.flatMap((entry) => entry.pattern.g_r)))
+
+  const series = $derived<DataSeries[]>(
+    entries.map((ent, idx) => ({
+      x: ent.pattern.r,
+      y: ent.pattern.g_r,
+      label: ent.label,
+      legend_group: ent.legend_group,
+      visible: mode === `element_pairs` ? idx < 3 : true,
+      markers: `line` as const,
+      line_style: {
+        stroke: ent.color ?? PLOT_COLORS[idx % PLOT_COLORS.length],
+        stroke_width: 2,
+      },
+    })),
+  )
+</script>
+
+<StatusMessage bind:message={error_msg} type="error" dismissible />
+
+{#if enable_drop && drag_dropped.length > 0}
+  <div class="dropped-info">
+    {drag_dropped.length} structure{drag_dropped.length > 1 ? `s` : ``} loaded
+    <button onclick={() => (drag_dropped = [])}>Clear</button>
+  </div>
+{/if}
+
+{#if series.length === 0}
+  <!-- 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}
+    {series}
+    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` : ``}"
+    style={rest.style ?? `height: 400px;`}
+    ondragover={enable_drop ? handle_dragover : 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)}
+          {@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}
+      {/if}
+    {/snippet}
+
+    {@render children?.({ drag_dropped })}
+  </ScatterPlot>
+{/if}
+
+<style>
+  :global(.dragging) {
+    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;
+    background: #f0f0f0;
+    border-radius: 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,27 @@
+import { ScatterPlot } from '../plot';
+import type { Crystal, Pbc } from '../structure';
+import type { ComponentProps, Snippet } from 'svelte';
+import { type RdfEntry } from './index';
+type $$ComponentProps = {
+    patterns?: RdfEntry | RdfEntry[];
+    structures?: Crystal | Crystal[] | Record<string, Crystal>;
+    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;
+    on_file_drop?: (content: string | ArrayBuffer, filename: string) => void;
+    loading?: boolean;
+    error_msg?: string;
+    children?: Snippet<[{
+        drag_dropped: Crystal[];
+    }]>;
+    drag_dropped?: Crystal[];
+    dragging?: boolean;
+} & ComponentProps<typeof ScatterPlot>;
+declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "loading" | "error_msg" | "dragging" | "drag_dropped">;
+type RdfPlot = ReturnType<typeof RdfPlot>;
+export default RdfPlot;

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

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

package/dist/rdf/calc-rdf.js

@@ -0,0 +1,98 @@
+import { calc_lattice_params, create_lattice_converters, euclidean_dist, pbc_dist, } from '../math';
+import { make_supercell } from '../structure/supercell';
+const get_occu = (site, elem) => elem ? (site.species.find((spec) => spec.element === elem)?.occu ?? 0) : 1;
+const has_species = (site, elem) => !elem || site.species.some((spec) => spec.element === elem);
+const sum_occu = (sites, elem) => sites.reduce((sum, site) => sum + get_occu(site, elem), 0);
+// Calculate radial distribution function
+export function calculate_rdf(structure, options = {}) {
+    const { center_species, neighbor_species, cutoff = 15, n_bins = 75, auto_expand = true, expansion_factor = 2.0, } = options;
+    const { pbc = [true, true, true] } = options;
+    if (cutoff <= 0 || n_bins <= 0) {
+        throw new Error(`cutoff and n_bins must be positive`);
+    }
+    // Validate structure has lattice
+    if (!structure.lattice?.matrix) {
+        throw new Error(`Crystal must have a lattice for RDF calculation`);
+    }
+    let lattice = structure.lattice.matrix;
+    let { sites } = structure;
+    let center_sites = sites;
+    // Expand structure if needed to ensure shortest lattice vector is expansion_factor× the cutoff
+    // This prevents artificial close contacts at cell boundaries when using PBC
+    // Standard practice uses 2.0-2.5× to eliminate finite-size effects
+    if (auto_expand) {
+        const { a, b, c } = calc_lattice_params(lattice);
+        const min_size = cutoff * expansion_factor;
+        const [n_a, n_b, n_c] = [a, b, c].map((len) => Math.ceil(min_size / len));
+        if (n_a > 1 || n_b > 1 || n_c > 1) {
+            const expanded_structure = make_supercell(structure, [n_a, n_b, n_c], false);
+            sites = expanded_structure.sites;
+            lattice = expanded_structure.lattice.matrix;
+            // Keep PBC: min-image is exact once every lattice vector ≥ 2× cutoff (disabling PBC
+            // starves boundary atoms and biases g(r) low). Under full PBC all periodic copies are
+            // equivalent, so restrict centers to the first copy (make_supercell emits (0,0,0) first)
+            center_sites = pbc.every(Boolean) ? sites.slice(0, structure.sites.length) : sites;
+        }
+    }
+    const bin_size = cutoff / n_bins;
+    const r = Array.from({ length: n_bins }, (_, idx) => (idx + 0.5) * bin_size);
+    const g_r = Array(n_bins).fill(0);
+    if (sites.length === 0)
+        return { r, g_r };
+    // Get occupancy weight for a site-species pair (supports mixed occupancy)
+    const centers = center_sites.filter((site) => has_species(site, center_species));
+    const neighbors = sites.filter((site) => has_species(site, neighbor_species));
+    if (centers.length === 0 || neighbors.length === 0) {
+        const element_pair = center_species && neighbor_species
+            ? [center_species, neighbor_species]
+            : undefined;
+        return { r, g_r, element_pair };
+    }
+    // Calculate distances and bin them with occupancy weighting
+    const use_pbc = pbc.some(Boolean);
+    const converters = use_pbc ? create_lattice_converters(lattice) : undefined;
+    for (const center of centers) {
+        for (const neighbor of neighbors) {
+            if (center === neighbor)
+                continue;
+            const dist = use_pbc
+                ? pbc_dist(center.xyz, neighbor.xyz, lattice, converters, pbc)
+                : euclidean_dist(center.xyz, neighbor.xyz);
+            if (dist > 0 && dist < cutoff) {
+                // Weight by product of occupancies for the species pair
+                const weight = get_occu(center, center_species) * get_occu(neighbor, neighbor_species);
+                g_r[Math.min(Math.floor(dist / bin_size), n_bins - 1)] += weight;
+            }
+        }
+    }
+    // Normalize using occupancy-weighted pair count (excludes self-interactions for same species)
+    const center_weight = sum_occu(centers, center_species);
+    const neighbor_weight = sum_occu(neighbors, neighbor_species);
+    const self_weight = center_species === neighbor_species
+        ? centers.reduce((sum, site) => sum + get_occu(site, center_species) ** 2, 0)
+        : 0;
+    const n_pairs = center_weight * neighbor_weight - self_weight;
+    if (n_pairs > 0) {
+        const volume = calc_lattice_params(lattice).volume;
+        for (let idx = 0; idx < n_bins; idx++) {
+            g_r[idx] /= n_pairs * ((4 * Math.PI * r[idx] ** 2 * bin_size) / volume);
+        }
+    }
+    const element_pair = center_species && neighbor_species
+        ? [center_species, neighbor_species]
+        : undefined;
+    return { r, g_r, element_pair };
+}
+// Calculate RDF for all element pairs
+export function calculate_all_pair_rdfs(structure, options = {}) {
+    // Collect all unique elements across all species (supports mixed occupancy)
+    const elems = [
+        ...new Set(structure.sites.flatMap((site) => site.species.map((spec) => spec.element))),
+    ].sort();
+    // Forward options unchanged (preserves caller's pbc); each calculate_rdf expands itself
+    return elems.flatMap((el1, idx1) => elems.slice(idx1).map((el2) => calculate_rdf(structure, {
+        ...options,
+        center_species: el1,
+        neighbor_species: el2,
+    })));
+}

package/dist/rdf/index.d.ts

@@ -0,0 +1,23 @@
+import type { Pbc } from '../structure';
+export * from './calc-rdf';
+export { default as RdfPlot } from './RdfPlot.svelte';
+export type RdfPattern = {
+    r: number[];
+    g_r: number[];
+    element_pair?: [string, string];
+};
+export interface RdfEntry {
+    label: string;
+    pattern: RdfPattern;
+    color?: string;
+    legend_group?: string;
+}
+export interface RdfOptions {
+    center_species?: string;
+    neighbor_species?: string;
+    cutoff?: number;
+    n_bins?: number;
+    pbc?: Pbc;
+    auto_expand?: boolean;
+    expansion_factor?: number;
+}

package/dist/rdf/index.js

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

package/dist/sanitize.d.ts

@@ -0,0 +1,6 @@
+export declare function sanitize_html(html: unknown): string;
+export declare const compact_formula: (formula: string) => string;
+export declare const sanitize_formula: (formula: string, use_subscripts?: boolean) => string;
+export declare const sanitize_compact_formula: (formula: string, use_subscripts?: boolean) => string;
+export declare const sanitize_svg: (html: string) => string;
+export declare const sanitize_icon_svg: (html: string) => string;