matterviz 0.4.2 → 0.4.3

package/dist/rdf/calc-rdf.js

@@ -1,61 +1,77 @@
 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);
+// Symmetric ± lattice images on expanded PBC axes. Extents use reciprocal-axis norms
+// with search radius cutoff + cell diagonal (length-based ceil undercounts skewed cells).
+function build_rdf_neighbor_sites(structure, pbc, cutoff, auto_expand) {
+    const dist_lattice = structure.lattice.matrix;
+    if (!auto_expand)
+        return { sites: structure.sites, dist_pbc: pbc, dist_lattice };
+    const [[ax, ay, az], [bx, by, bz], [cx, cy, cz]] = dist_lattice;
+    let cell_diag = 0;
+    for (let bits = 0; bits < 8; bits++) {
+        const [ua, ub, uc] = [bits & 1, (bits >> 1) & 1, (bits >> 2) & 1];
+        cell_diag = Math.max(cell_diag, Math.hypot(ua * ax + ub * bx + uc * cx, ua * ay + ub * by + uc * cy, ua * az + ub * bz + uc * cz));
+    }
+    const { reciprocal_axis_norms } = create_lattice_converters(dist_lattice);
+    const search_radius = cutoff + cell_diag;
+    const extents = [0, 1, 2].map((axis) => pbc[axis]
+        ? Math.max(0, Math.ceil(search_radius * reciprocal_axis_norms[axis] - 1e-12))
+        : 0);
+    if (extents.every((extent) => extent === 0)) {
+        return { sites: structure.sites, dist_pbc: pbc, dist_lattice };
+    }
+    const sites = [];
+    for (let ia = -extents[0]; ia <= extents[0]; ia++) {
+        for (let ib = -extents[1]; ib <= extents[1]; ib++) {
+            for (let ic = -extents[2]; ic <= extents[2]; ic++) {
+                const tx = ia * ax + ib * bx + ic * cx;
+                const ty = ia * ay + ib * by + ic * cy;
+                const tz = ia * az + ib * bz + ic * cz;
+                for (const site of structure.sites) {
+                    sites.push({ ...site, xyz: [site.xyz[0] + tx, site.xyz[1] + ty, site.xyz[2] + tz] });
+                }
+            }
+        }
+    }
+    const dist_pbc = [
+        pbc[0] && extents[0] === 0,
+        pbc[1] && extents[1] === 0,
+        pbc[2] && extents[2] === 0,
+    ];
+    return { sites, dist_pbc, dist_lattice };
+}
 // 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;
+    const { center_species, neighbor_species, cutoff = 15, n_bins = 75, auto_expand = true, } = options;
+    const pbc = options.pbc ?? structure.lattice?.pbc ?? [true, true, true];
     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 { sites: neighbor_sites, dist_pbc, dist_lattice, } = build_rdf_neighbor_sites(structure, pbc, cutoff, auto_expand);
     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));
+    // Centers stay in the original cell; neighbor_sites may include periodic images
+    const centers = structure.sites.filter((site) => has_species(site, center_species));
+    const neighbors = neighbor_sites.filter((site) => has_species(site, neighbor_species));
+    // Normalization density uses the original cell (not the image cloud)
+    const norm_neighbors = structure.sites.filter((site) => has_species(site, neighbor_species));
     const element_pair = center_species && neighbor_species
         ? [center_species, neighbor_species]
         : undefined;
     if (centers.length === 0 || neighbors.length === 0)
         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;
+    const use_pbc = dist_pbc.some(Boolean);
+    const converters = use_pbc ? create_lattice_converters(dist_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)
+                ? pbc_dist(center.xyz, neighbor.xyz, dist_lattice, converters, dist_pbc)
                 : euclidean_dist(center.xyz, neighbor.xyz);
             if (dist > 0 && dist < cutoff) {
                 // Weight by product of occupancies for the species pair
@@ -64,17 +80,16 @@ export function calculate_rdf(structure, options = {}) {
             }
         }
     }
-    // Normalize using occupancy-weighted pair count (excludes self-interactions for same species)
+    // Ideal-gas normalization with original-cell density. Do not subtract self-pairs:
+    // dist > 0 already drops the true self term, while periodic images of the same atom
+    // are valid neighbors (critical for 1-atom cells).
     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;
+    const neighbor_weight = sum_occu(norm_neighbors, neighbor_species);
+    const volume = calc_lattice_params(structure.lattice.matrix).volume;
+    if (center_weight > 0 && neighbor_weight > 0 && volume > 0) {
         for (let idx = 0; idx < n_bins; idx++) {
-            g_r[idx] /= n_pairs * ((4 * Math.PI * r[idx] ** 2 * bin_size) / volume);
+            g_r[idx] /=
+                center_weight * neighbor_weight * ((4 * Math.PI * r[idx] ** 2 * bin_size) / volume);
         }
     }
     return { r, g_r, element_pair };

package/dist/rdf/index.d.ts

@@ -19,5 +19,4 @@ export interface RdfOptions {
     n_bins?: number;
     pbc?: Pbc;
     auto_expand?: boolean;
-    expansion_factor?: number;
 }

package/dist/sanitize.js

@@ -1,10 +1,12 @@
 import DOMPurify from 'dompurify';
 import { format_formula_html } from './phase-diagram/utils';
+import { escape_html } from './utils';
 const SAFE_TAGS = [`a`, `b`, `i`, `em`, `strong`, `sub`, `sup`, `br`, `span`, `code`, `small`];
 const SAFE_ATTRS = [`style`, `class`, `title`, `href`, `target`, `rel`];
+const SAFE_TAG_SET = new Set(SAFE_TAGS);
+const SAFE_ATTR_SET = new Set(SAFE_ATTRS);
 // only allow safe CSS properties for text formatting
 const SAFE_STYLE_RE = /^\s*(?:color|font-weight|font-style|font-size|text-decoration|vertical-align)\s*:/;
-// Add a token to a space-separated string if not already present
 const ensure_token = (value, token) => {
     const tokens = new Set(value.split(/\s+/).filter(Boolean));
     tokens.add(token);
@@ -18,10 +20,8 @@ function get_purify() {
     if (typeof globalThis.window === `undefined`)
         return (purify = null);
     const instance = DOMPurify();
-    if (typeof instance.sanitize !== `function`) {
-        purify = null;
-        return null;
-    }
+    if (typeof instance.sanitize !== `function`)
+        return (purify = null);
     purify = instance;
     instance.addHook(`uponSanitizeAttribute`, (node, data) => {
         if (data.attrName === `style`) {
@@ -35,21 +35,83 @@ function get_purify() {
         if (data.attrName === `href`) {
             node.setAttribute(`rel`, ensure_token(node.getAttribute(`rel`) ?? ``, `noopener`));
         }
-        if (data.attrName === `rel`) {
+        if (data.attrName === `rel`)
             data.attrValue = ensure_token(data.attrValue, `noopener`);
-        }
     });
     return instance;
 }
+// Strip void / raw-text blocks that must not leak content when tags are removed
+const DANGEROUS_BLOCK_RE = /<(?<block>script|style|iframe|object|embed|textarea|noscript|template)\b[^>]*>[\s\S]*?<\/\k<block>\s*>/gi;
+const ATTR_RE = /(?<name>[^\s=]+)(?:\s*=\s*(?:"(?<dq>[^"]*)"|'(?<sq>[^']*)'|(?<bare>[^\s"'=<>`]+)))?/g;
+const SAFE_HREF_RE = /^(?:\/|#|https?:|mailto:)/i;
+function filter_attrs(attr_str, allowed, tag) {
+    let out = ``;
+    let rel = ``;
+    let has_href = false;
+    ATTR_RE.lastIndex = 0;
+    for (const match of attr_str.matchAll(ATTR_RE)) {
+        const name = (match.groups?.name ?? ``).toLowerCase();
+        if (name.startsWith(`on`) || !allowed.has(name))
+            continue;
+        const raw = match.groups?.dq ?? match.groups?.sq ?? match.groups?.bare ?? ``;
+        if (name === `rel`) {
+            rel = raw;
+            continue;
+        }
+        if (name === `href`) {
+            if (!SAFE_HREF_RE.test(raw.trim()))
+                continue;
+            has_href = true;
+        }
+        else if (name === `style`) {
+            const rules = raw.split(`;`).filter((rule) => SAFE_STYLE_RE.test(rule));
+            if (rules.length === 0)
+                continue;
+            out += ` style="${escape_html(rules.join(`;`))}"`;
+            continue;
+        }
+        out += ` ${name}="${escape_html(raw)}"`;
+    }
+    if (tag === `a` && (has_href || rel)) {
+        out += ` rel="${escape_html(ensure_token(rel, `noopener`))}"`;
+    }
+    return out;
+}
+// DOM-free allowlist sanitizer for SSR / no-window contexts. Never returns raw input.
+function sanitize_allowlist_ssr(html, tags, attrs) {
+    const without_blocks = html
+        .replace(DANGEROUS_BLOCK_RE, ``)
+        .replaceAll(/<!--[\s\S]*?-->/g, ``);
+    const tag_re = /<\/?(?<tag>[A-Za-z][\w:-]*)\b(?<attrs>[^>]*)\/?>/g;
+    let out = ``;
+    let last = 0;
+    for (const match of without_blocks.matchAll(tag_re)) {
+        out += without_blocks.slice(last, match.index);
+        last = match.index + match[0].length;
+        const name = (match.groups?.tag ?? ``).toLowerCase();
+        if (!tags.has(name))
+            continue;
+        if (match[0].startsWith(`</`)) {
+            out += `</${name}>`;
+            continue;
+        }
+        const filtered = filter_attrs(match.groups?.attrs ?? ``, attrs, name);
+        out +=
+            match[0].endsWith(`/>`) || name === `br`
+                ? `<${name}${filtered} />`
+                : `<${name}${filtered}>`;
+    }
+    return out + without_blocks.slice(last);
+}
 // Wrap in <svg>, sanitize with allowlist, then unwrap. Required because DOMPurify
 // needs the <svg> parent to parse children in the SVG namespace.
-function sanitize_svg_content(html, allowed_tags, allowed_attrs) {
+function sanitize_svg_content(html, tags, attrs) {
     const dp = get_purify();
     if (!dp)
-        return html;
+        return sanitize_allowlist_ssr(html, tags, new Set(attrs));
     const wrapped = dp.sanitize(`<svg>${html}</svg>`, {
-        ALLOWED_TAGS: [...allowed_tags, `svg`],
-        ALLOWED_ATTR: allowed_attrs,
+        ALLOWED_TAGS: [...tags, `svg`],
+        ALLOWED_ATTR: [...attrs],
     });
     const open_end = wrapped.indexOf(`>`);
     const close_start = wrapped.lastIndexOf(`</svg>`);
@@ -75,10 +137,13 @@ const stringify_html_input = (html) => {
         return ``;
     }
 };
-// Memoize by input: two DOMPurify passes per call are costly when a component re-sanitizes
-// many cells on every render (e.g. HeatmapTable). Sanitization is deterministic for the
-// fixed config, so caching is output-identical.
 const sanitize_cache = new Map();
+const cache_sanitize = (key, result) => {
+    if (sanitize_cache.size >= 4096)
+        sanitize_cache.clear();
+    sanitize_cache.set(key, result);
+    return result;
+};
 // Sanitize HTML string, allowing only safe formatting tags and links.
 // Two-pass: happy-dom promotes dangerous children when a non-allowed parent is
 // stripped (e.g. <div><script>…</script></div> → <script>…</script>). The first
@@ -90,32 +155,26 @@ export function sanitize_html(html) {
         return cached;
     const dp = get_purify();
     if (!dp)
-        return str; // no DOM (SSR): return as-is, don't cache
+        return cache_sanitize(str, sanitize_allowlist_ssr(str, SAFE_TAG_SET, SAFE_ATTR_SET));
     // oxfmt-ignore
     const safe = dp.sanitize(str, { ADD_ATTR: [`target`], FORBID_TAGS: [
             `script`, `style`, `iframe`, `object`, `embed`, `form`, `input`, `textarea`,
             `select`, `button`, `meta`, `link`, `base`, `template`, `noscript`,
         ] });
-    const result = dp.sanitize(safe, { ALLOWED_TAGS: SAFE_TAGS, ALLOWED_ATTR: SAFE_ATTRS });
-    if (sanitize_cache.size >= 4096)
-        sanitize_cache.clear(); // bound memory (rarely hit)
-    sanitize_cache.set(str, result);
-    return result;
+    return cache_sanitize(str, dp.sanitize(safe, { ALLOWED_TAGS: SAFE_TAGS, ALLOWED_ATTR: SAFE_ATTRS }));
 }
 export const compact_formula = (formula) => formula.replaceAll(/\s+/g, ``);
-// Sanitize a chemical formula with optional subscript formatting
 export const sanitize_formula = (formula, use_subscripts = true) => sanitize_html(format_formula_html(formula, use_subscripts));
 export const sanitize_compact_formula = (formula, use_subscripts = true) => sanitize_formula(compact_formula(formula), use_subscripts);
-const SVG_TEXT_TAGS = [`tspan`, `title`];
+const SVG_TEXT_TAGS = new Set([`tspan`, `title`]);
 // oxfmt-ignore
 const SVG_TEXT_ATTRS = [`dx`, `dy`, `x`, `y`, `fill`, `font-size`, `font-weight`, `baseline-shift`];
-// Sanitize HTML intended for SVG text contexts (tspan, title)
 export const sanitize_svg = (html) => sanitize_svg_content(html, SVG_TEXT_TAGS, SVG_TEXT_ATTRS);
 // oxfmt-ignore
-const SVG_ICON_TAGS = [
+const SVG_ICON_TAGS = new Set([
     `path`, `circle`, `rect`, `line`, `polyline`, `polygon`, `g`, `ellipse`,
     `clipPath`, `defs`, `mask`, `use`, `title`,
-];
+]);
 // oxfmt-ignore
 const SVG_ICON_ATTRS = [
     `d`, `fill`, `stroke`, `stroke-width`, `stroke-linecap`, `stroke-linejoin`,
@@ -123,5 +182,4 @@ const SVG_ICON_ATTRS = [
     `width`, `height`, `viewBox`, `points`, `transform`, `opacity`,
     `clip-path`, `clip-rule`, `fill-rule`, `id`, `class`,
 ];
-// Sanitize inline SVG markup (path, circle, rect, etc.) for icon rendering
 export const sanitize_icon_svg = (html) => sanitize_svg_content(html, SVG_ICON_TAGS, SVG_ICON_ATTRS);

package/dist/scene/SceneCamera.svelte

@@ -5,7 +5,7 @@
   import { T } from '@threlte/core'
   import * as extras from '@threlte/extras'
   import type { ComponentProps } from 'svelte'
-  import { build_gizmo_props, build_orbit_props } from './props'
+  import { build_gizmo_props, build_orbit_props } from './props.svelte'
 
   let {
     camera_projection = `perspective`,

package/dist/scene/SceneCamera.svelte.d.ts

@@ -2,7 +2,7 @@ import type { Vec3 } from '../math';
 import { type CameraProjection } from '../settings';
 import * as extras from '@threlte/extras';
 import type { ComponentProps } from 'svelte';
-import { build_orbit_props } from './props';
+import { build_orbit_props } from './props.svelte';
 type $$ComponentProps = {
     camera_projection?: CameraProjection;
     position: Vec3;

package/dist/scene/index.d.ts

@@ -1,4 +1,3 @@
 export * from './bind-renderer.svelte';
-export * from './props';
+export * from './props.svelte';
 export { default as SceneCamera } from './SceneCamera.svelte';
-export type * from './types';

package/dist/scene/index.js

@@ -1,5 +1,5 @@
 // Shared Three.js/Threlte scene boilerplate (cameras, orbit controls, gizmo,
 // renderer binding) used by BrillouinZoneScene, FermiSurfaceScene and StructureScene.
 export * from './bind-renderer.svelte';
-export * from './props';
+export * from './props.svelte';
 export { default as SceneCamera } from './SceneCamera.svelte';

package/dist/scene/{props.js → props.svelte.js}

@@ -1,4 +1,15 @@
 import { AXIS_COLORS, NEG_AXIS_COLORS } from '../colors';
+// Reactive page visibility — pause auto-rotation while the tab/window is
+// hidden. Desktop embedders like Tauri often disable background throttling,
+// which would otherwise leave every auto-rotating WebGL canvas burning GPU.
+export const page_visibility = $state({
+    visible: typeof document === `undefined` || document.visibilityState === `visible`,
+});
+if (typeof document !== `undefined`) {
+    document.addEventListener(`visibilitychange`, () => {
+        page_visibility.visible = document.visibilityState === `visible`;
+    });
+}
 // ScatterPlot3DScene keeps its own gizmo/orbit props on purpose: its gizmo offset is
 // ColorBar-aware (build_gizmo_props' fixed offset would clobber it) and its orbit controls
 // differ by design (no zoom-to-cursor / ortho zoom-doubling / camera-moving tracking).
@@ -39,7 +50,10 @@ export function build_orbit_props(opts) {
         panSpeed: opts.pan_speed,
         maxZoom: opts.max_zoom,
         minZoom: opts.min_zoom,
-        autoRotate: Boolean(opts.auto_rotate),
+        // pause auto-rotation while the page is hidden: callers build these props
+        // in $derived, so the visibility flip re-runs them and stops the per-frame
+        // OrbitControls task (threlte only runs it while autoRotate/damping is on)
+        autoRotate: Boolean(opts.auto_rotate) && page_visibility.visible,
         autoRotateSpeed: opts.auto_rotate,
         enableDamping: Boolean(opts.rotation_damping),
         dampingFactor: opts.rotation_damping,