matterviz 0.3.5 → 0.3.7

package/dist/trajectory/index.js

@@ -80,7 +80,7 @@ export function get_trajectory_stats(trajectory) {
     const frame_count = total_frames || frames.length;
     const stats = {
         frame_count,
-        is_indexed: trajectory.is_indexed || false,
+        is_indexed: trajectory.is_indexed ?? false,
     };
     if (frames.length > 0) {
         const [first_frame, last_frame] = [frames[0], frames.at(-1) ?? frames[0]];
@@ -98,7 +98,7 @@ export function get_trajectory_stats(trajectory) {
                 return result;
             })();
         const counts = sampled.map((frame) => frame.structure.sites.length);
-        const constant = counts.every((c) => c === counts[0]);
+        const constant = counts.every((count) => count === counts[0]);
         const all_counts = constant
             ? [first_frame.structure.sites.length]
             : frames.map((frame) => frame.structure.sites.length);

package/dist/trajectory/parse/ase.js

@@ -31,11 +31,11 @@ export function parse_ase_trajectory(buffer, filename) {
                 continue;
             }
             const frame_data = JSON.parse(new TextDecoder().decode(new Uint8Array(buffer, offset, json_length)));
-            const positions_ref = frame_data[`positions.`] || frame_data.positions;
+            const positions_ref = frame_data[`positions.`] ?? frame_data.positions;
             const positions = positions_ref?.ndarray
                 ? read_ndarray_from_view(view, positions_ref)
                 : positions_ref;
-            const numbers_ref = frame_data[`numbers.`] || frame_data.numbers || global_numbers;
+            const numbers_ref = frame_data[`numbers.`] ?? frame_data.numbers ?? global_numbers;
             const numbers = numbers_ref?.ndarray
                 ? read_ndarray_from_view(view, numbers_ref).flat()
                 : numbers_ref;
@@ -47,7 +47,7 @@ export function parse_ase_trajectory(buffer, filename) {
             }
             const elements = convert_atomic_numbers(numbers);
             const metadata = { step: idx, ...frame_data.calculator, ...frame_data.info };
-            frames.push(create_trajectory_frame(positions, elements, frame_data.cell ? validate_3x3_matrix(frame_data.cell) : undefined, frame_data.pbc || [true, true, true], idx, metadata));
+            frames.push(create_trajectory_frame(positions, elements, frame_data.cell ? validate_3x3_matrix(frame_data.cell) : undefined, frame_data.pbc ?? [true, true, true], idx, metadata));
         }
         catch (error) {
             console.warn(`Error processing frame ${idx + 1}/${n_items}:`, error);
@@ -66,7 +66,7 @@ export function parse_ase_trajectory(buffer, filename) {
         filename,
         source_format: `ase_trajectory`,
         frame_count: frames.length,
-        total_atoms: global_numbers?.length || 0,
+        total_atoms: global_numbers?.length ?? 0,
         periodic_boundary_conditions,
     };
     return { frames, metadata };

package/dist/trajectory/parse/hdf5.js

@@ -25,7 +25,7 @@ export async function parse_torch_sim_hdf5(buffer, filename) {
                     const item = parent.get(name);
                     const full_path = path ? `${path}/${name}` : `/${name}`;
                     if (names.includes(name) && is_hdf5_dataset(item)) {
-                        const found_name = names.find((n) => n === name);
+                        const found_name = names.find((dataset_name) => dataset_name === name);
                         if (found_name)
                             found_paths[found_name] = full_path;
                         return item;

package/dist/trajectory/parse/index.js

@@ -19,9 +19,8 @@ export async function parse_trajectory_data(data, filename, atom_type_mapping) {
     if (data instanceof ArrayBuffer) {
         if (FORMAT_PATTERNS.ase(data, filename))
             return parse_ase_trajectory(data, filename);
-        if (FORMAT_PATTERNS.hdf5(data, filename)) {
-            return await parse_torch_sim_hdf5(data, filename);
-        }
+        if (FORMAT_PATTERNS.hdf5(data, filename))
+            return parse_torch_sim_hdf5(data, filename);
         throw new Error(`Unsupported binary format${filename ? `: ${filename}` : ``}`);
     }
     if (typeof data === `string`) {

package/dist/trajectory/parse/lammps.js

@@ -1,6 +1,7 @@
 import { ELEM_SYMBOLS } from '../../labels';
 import * as math from '../../math';
 import { coerce_element_symbol, create_trajectory_frame } from '../helpers';
+const is_periodic = (token) => token.toLowerCase().startsWith(`p`);
 // Parse LAMMPS box bounds → lattice matrix. Handles orthogonal and triclinic boxes.
 // Triclinic: converts bounding box to actual dims per https://docs.lammps.org/Howto_triclinic.html
 // Lattice vectors: a=(lx,0,0), b=(xy,ly,0), c=(xz,yz,lz)
@@ -70,7 +71,6 @@ export function parse_lammps_trajectory(content, filename, atom_type_mapping) {
         const box_header = read_line();
         const is_triclinic = /BOX BOUNDS\s+xy\s+xz\s+yz/i.test(box_header);
         const tokens = box_header.replace(`ITEM: BOX BOUNDS`, ``).trim().split(/\s+/).slice(-3);
-        const is_periodic = (tok) => tok.toLowerCase().startsWith(`p`);
         const pbc = tokens.length === 3
             ? [is_periodic(tokens[0]), is_periodic(tokens[1]), is_periodic(tokens[2])]
             : [true, true, true];

package/dist/trajectory/parse/vasp.js

@@ -10,7 +10,7 @@ export function parse_vasp_xdatcar(content, filename) {
     const lattice_matrix = validate_3x3_matrix(lines.slice(2, 5).map((line) => line
         .trim()
         .split(/\s+/)
-        .map((x) => parseFloat(x) * scale)));
+        .map((component) => parseFloat(component) * scale)));
     const element_names = lines[5].trim().split(/\s+/);
     const element_counts = lines[6].trim().split(/\s+/).map(Number);
     if (element_names.length !== element_counts.length) {

package/dist/trajectory/plotting.d.ts

@@ -1,4 +1,4 @@
-import type { DataSeries } from '../plot';
+import type { DataSeries } from '../plot/types';
 import type { TrajectoryDataExtractor, TrajectoryMetadata, TrajectoryType } from './index';
 export interface PlotSeriesOptions {
     property_config?: Record<string, {

package/dist/trajectory/plotting.js

@@ -49,8 +49,8 @@ function extract_property_statistics(trajectory, data_extractor) {
     // Convert to final format with variation detection
     const result = new Map();
     for (const [key, stat] of property_stats) {
-        const n = stat.values.length;
-        if (n <= 1)
+        const n_values = stat.values.length;
+        if (n_values <= 1)
             continue;
         const coefficient_of_variation = get_coefficient_of_variation(stat.values);
         const lower_key = key.toLowerCase();
@@ -74,18 +74,18 @@ function create_series_from_stats(property_stats, property_config, colors) {
     for (const [key, stat] of property_stats) {
         if (!stat)
             continue;
-        const n = stat.values.length;
+        const n_values = stat.values.length;
         const { clean_label, unit } = extract_label_and_unit(key, property_config);
         const color = colors[color_idx % colors.length];
         all_series.push({
-            x: Array.from({ length: n }, (_, idx) => idx),
+            x: Array.from({ length: n_values }, (_, idx) => idx),
             y: stat.values,
             label: clean_label,
             unit,
             y_axis: `y1`, // Will be reassigned
             visible: false, // Will be assigned
-            markers: n < 30 ? `line+points` : `line`,
-            metadata: Array(n).fill({
+            markers: n_values < 30 ? `line+points` : `line`,
+            metadata: Array(n_values).fill({
                 series_label: unit ? `${clean_label} (${unit})` : clean_label,
                 property_key: key, // Store original property key for robust lookups
             }),
@@ -119,7 +119,7 @@ function group_and_assign_series(series, default_visible_properties) {
     })
         .sort((a, b) => a.priority - b.priority);
     // Apply 2-group visibility limit
-    const visible_groups = groups.filter((g) => g.is_visible);
+    const visible_groups = groups.filter((group) => group.is_visible);
     if (visible_groups.length > 2) {
         // Keep only first 2 (highest priority)
         groups.forEach((group) => {
@@ -133,7 +133,7 @@ function group_and_assign_series(series, default_visible_properties) {
 }
 // Apply group assignments to individual series
 function apply_group_assignments(series, unit_groups) {
-    const visible_groups = unit_groups.filter((g) => g.is_visible);
+    const visible_groups = unit_groups.filter((group) => group.is_visible);
     const axis_map = new Map();
     // Assign axes
     if (visible_groups.length === 1) {
@@ -145,10 +145,10 @@ function apply_group_assignments(series, unit_groups) {
     }
     // Apply to series
     for (const srs of series) {
-        const group = unit_groups.find((g) => g.series.includes(srs));
+        const group = unit_groups.find((unit_group) => unit_group.series.includes(srs));
         if (group) {
             srs.visible = group.is_visible;
-            srs.y_axis = axis_map.get(group) || `y1`;
+            srs.y_axis = axis_map.get(group) ?? `y1`;
         }
     }
 }
@@ -209,7 +209,7 @@ export function toggle_series_visibility(series, target_series_idx) {
     const new_visibility = !target_series.visible;
     // Create unit groups from current state
     const unit_groups = create_unit_groups_from_series(series);
-    const target_group = unit_groups.find((g) => g.series.includes(target_series));
+    const target_group = unit_groups.find((group) => group.series.includes(target_series));
     if (!target_group)
         return series;
     // Start with updating the target series visibility
@@ -262,8 +262,8 @@ function update_group_visibility_and_axes(series, unit_groups) {
         group.is_visible = group.series.some((srs1) => series.find((srs2) => srs2.label === srs1.label && srs2.unit === srs1.unit)?.visible);
     }
     // Apply 2-group limit
-    if (unit_groups.filter((g) => g.is_visible).length > 2) {
-        for (const group of unit_groups.filter((g) => g.is_visible).slice(2)) {
+    if (unit_groups.filter((unit_group) => unit_group.is_visible).length > 2) {
+        for (const group of unit_groups.filter((unit_group) => unit_group.is_visible).slice(2)) {
             group.is_visible = false;
             for (const srs1 of group.series) {
                 const idx = series.findIndex((srs2) => srs2.label === srs1.label && srs2.unit === srs1.unit);
@@ -283,7 +283,7 @@ function update_group_visibility_and_axes(series, unit_groups) {
         axis_map.set(final_visible[1], `y2`);
     // Apply to series
     for (const [idx, srs] of series.entries()) {
-        const group = unit_groups.find((g) => g.series.some((gs) => gs.label === srs.label && gs.unit === srs.unit));
+        const group = unit_groups.find((unit_group) => unit_group.series.some((member) => member.label === srs.label && member.unit === srs.unit));
         if (group && axis_map.has(group)) {
             series[idx] = { ...srs, y_axis: axis_map.get(group) };
         }
@@ -311,30 +311,30 @@ export function should_hide_plot(trajectory, plot_series, tolerance = 1e-10) {
         return valid_values.every((value) => Math.abs(value - first_valid) <= tolerance);
     });
 }
+function get_axis_label(axis_series) {
+    const visible_series = axis_series.filter((srs) => srs.visible);
+    if (!visible_series.length)
+        return `Value`;
+    const unit_groups = new Map();
+    visible_series.forEach((srs) => {
+        const unit = srs.unit || ``;
+        const label = srs.label || `Value`;
+        if (!unit_groups.has(unit))
+            unit_groups.set(unit, []);
+        const group = unit_groups.get(unit);
+        if (group)
+            group.push(label);
+    });
+    const unit_entries = Array.from(unit_groups.entries());
+    if (!unit_entries.length)
+        return `Value`;
+    const [unit, labels] = unit_entries[0];
+    const unique_labels = [...new Set(labels)].sort().join(` / `);
+    return unit ? `${unique_labels} (${unit})` : unique_labels;
+}
 export function generate_axis_labels(plot_series) {
     if (!plot_series.length)
         return { y1: `Value`, y2: `Value` };
-    const get_axis_label = (axis_series) => {
-        const visible_series = axis_series.filter((srs) => srs.visible);
-        if (!visible_series.length)
-            return `Value`;
-        const unit_groups = new Map();
-        visible_series.forEach((srs) => {
-            const unit = srs.unit || ``;
-            const label = srs.label || `Value`;
-            if (!unit_groups.has(unit))
-                unit_groups.set(unit, []);
-            const group = unit_groups.get(unit);
-            if (group)
-                group.push(label);
-        });
-        const unit_entries = Array.from(unit_groups.entries());
-        if (!unit_entries.length)
-            return `Value`;
-        const [unit, labels] = unit_entries[0];
-        const unique_labels = [...new Set(labels)].sort().join(` / `);
-        return unit ? `${unique_labels} (${unit})` : unique_labels;
-    };
     return {
         y1: get_axis_label(plot_series.filter((srs) => (srs.y_axis ?? `y1`) === `y1`)),
         y2: get_axis_label(plot_series.filter((srs) => srs.y_axis === `y2`)),
@@ -362,7 +362,7 @@ export function generate_streaming_plot_series(metadata_list, options = {}) {
         if (data_points.length < 2)
             continue;
         const is_energy = property_key.toLowerCase() === `energy`;
-        if (!is_energy && !has_significant_variation(data_points.map((p) => p.y)))
+        if (!is_energy && !has_significant_variation(data_points.map((point) => point.y)))
             continue;
         const { clean_label, unit } = extract_label_and_unit(property_key, property_config);
         const is_visible = is_default_visible(property_key, default_visible_properties) || color_idx < 2;
@@ -370,8 +370,8 @@ export function generate_streaming_plot_series(metadata_list, options = {}) {
         if (is_visible)
             visible_props.push({ property: property_key, unit });
         all_series.push({
-            x: data_points.map((p) => p.x),
-            y: data_points.map((p) => p.y),
+            x: data_points.map((point) => point.x),
+            y: data_points.map((point) => point.y),
             label: clean_label,
             unit,
             y_axis: determine_axis_from_groups(property_key, unit, visible_props),

package/dist/trajectory/types.d.ts

@@ -1,4 +1,4 @@
-import type { ElementSymbol } from '../element';
+import type { ElementSymbol } from '../element/types';
 export type AtomTypeMapping = Record<number, ElementSymbol>;
 export interface LoadingOptions {
     use_indexing?: boolean;

package/dist/utils.d.ts

@@ -2,4 +2,5 @@ export declare function merge_nested<T extends Record<string, unknown>>(obj1: T,
 export declare const escape_html: (unsafe_string: string) => string;
 export declare const normalize_unicode_minus: (value: string) => string;
 export declare const normalize_scientific_notation: (value: string) => string;
+export declare function make_change_detector(): (value: unknown) => boolean;
 export declare function decode_url_safe_base64(encoded: string): string | undefined;

package/dist/utils.js

@@ -21,6 +21,15 @@ export const escape_html = (unsafe_string) => unsafe_string
 export const normalize_unicode_minus = (value) => value.replace(/−/g, `-`);
 // Normalize scientific notation variants (d/D exponent, Mathematica *^).
 export const normalize_scientific_notation = (value) => normalize_unicode_minus(value).toLowerCase().replace(/d/g, `e`).replace(/\*\^/g, `e`);
+export function make_change_detector() {
+    const unset = Symbol();
+    let prev = unset;
+    return (value) => {
+        const changed = prev !== unset && value !== prev;
+        prev = value;
+        return changed;
+    };
+}
 // Decode a URL-safe base64 string (RFC 4648 §5) to its original text.
 // Converts `-` → `+`, `_` → `/`, restores padding, then decodes.
 // Returns undefined if decoding fails.

package/dist/xrd/calc-xrd.js

@@ -33,9 +33,7 @@ export const WAVELENGTHS = {
     AgKb1: 0.497082,
 };
 // Type guard to safely check if a string is a valid RadiationKey
-function is_radiation_key(key) {
-    return key in WAVELENGTHS;
-}
+const is_radiation_key = (key) => key in WAVELENGTHS;
 // Tolerances from pymatgen.analysis.diffraction.core
 const TWO_THETA_TOL = 1e-5;
 const SCALED_INTENSITY_TOL = 1e-3;
@@ -296,7 +294,8 @@ wavelength) {
                 buffer_content = content;
             }
             else {
-                buffer_content = new Uint8Array(content).buffer;
+                buffer_content =
+                    content instanceof ArrayBuffer ? content : new Uint8Array(content).slice().buffer;
             }
             const pattern = await parse_xrd_file(buffer_content, filename);
             if (pattern && pattern.x.length > 0) {

package/dist/xrd/parse.js

@@ -734,7 +734,7 @@ export async function parse_xrd_file(content, filename) {
         return parse_xrdml_file(get_text());
     // Binary formats
     if (ext === `brml`)
-        return await parse_brml_file(get_buffer()); // async due to lazy fflate import
+        return parse_brml_file(get_buffer()); // async due to lazy fflate import
     if (ext === `raw`)
         return parse_bruker_raw_file(get_buffer());
     return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterviz",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Interactive visualizations for materials science: periodic tables, 3D structures, MD trajectories, heatmaps, scatter plots.",
   "keywords": [
     "chemistry",
@@ -49,6 +49,10 @@
       "types": "./dist/colors/index.d.ts",
       "default": "./dist/colors/index.js"
     },
+    "./coordination": {
+      "types": "./dist/coordination/index.d.ts",
+      "default": "./dist/coordination/index.js"
+    },
     "./element": {
       "types": "./dist/element/index.d.ts",
       "default": "./dist/element/index.js"
@@ -61,10 +65,18 @@
       "types": "./dist/fermi-surface/index.d.ts",
       "default": "./dist/fermi-surface/index.js"
     },
+    "./heatmap-matrix": {
+      "types": "./dist/heatmap-matrix/index.d.ts",
+      "default": "./dist/heatmap-matrix/index.js"
+    },
     "./io": {
       "types": "./dist/io/index.d.ts",
       "default": "./dist/io/index.js"
     },
+    "./isosurface": {
+      "types": "./dist/isosurface/index.d.ts",
+      "default": "./dist/isosurface/index.js"
+    },
     "./labels": {
       "types": "./dist/labels.d.ts",
       "default": "./dist/labels.js"
@@ -82,8 +94,8 @@
       "default": "./dist/overlays/index.js"
     },
     "./periodic-table": {
-      "types": "./dist/periodic-table.d.ts",
-      "default": "./dist/periodic-table.js"
+      "types": "./dist/periodic-table/index.d.ts",
+      "default": "./dist/periodic-table/index.js"
     },
     "./phase-diagram": {
       "types": "./dist/phase-diagram/index.d.ts",
@@ -156,16 +168,17 @@
   },
   "scripts": {
     "test": "vp test --run && playwright test",
+    "knip": "knip --include dependencies,devDependencies",
     "package-dist-assets": "NODE_OPTIONS=--experimental-strip-types node scripts/package-dist-assets.ts",
     "package:dist": "svelte-package && npm run package-dist-assets",
     "prepare": "NODE_OPTIONS=--experimental-strip-types svelte-kit sync && npm run package:dist",
     "prepublishOnly": "npm run package:dist"
   },
   "dependencies": {
-    "@spglib/moyo-wasm": "^0.9.0",
-    "@sveltejs/kit": "2.60.1",
-    "@threlte/core": "^8.5.14",
-    "@threlte/extras": "^9.19.0",
+    "@spglib/moyo-wasm": "^0.10.0",
+    "@sveltejs/kit": "2.61.1",
+    "@threlte/core": "^8.5.16",
+    "@threlte/extras": "^9.20.1",
     "d3-array": "^3.2.4",
     "d3-color": "^3.1.0",
     "d3-format": "^3.1.2",
@@ -175,16 +188,15 @@
     "d3-scale-chromatic": "^3.1.0",
     "d3-shape": "^3.2.0",
     "d3-time-format": "^4.1.0",
-    "dompurify": "^3.4.5",
+    "dompurify": "^3.4.7",
     "fflate": "^0.8.3",
-    "h5wasm": "^0.10.1",
+    "h5wasm": "^0.10.2",
     "js-yaml": "^4.1.1",
     "svelte-multiselect": "^11.7.1",
     "three": "^0.184.0"
   },
   "devDependencies": {
     "@playwright/test": "^1.60.0",
-    "@rollup/plugin-yaml": "^4.1.2",
     "@sveltejs/adapter-static": "3.0.10",
     "@sveltejs/package": "^2.5.7",
     "@sveltejs/vite-plugin-svelte": "^7.1.2",
@@ -198,31 +210,39 @@
     "@types/d3-shape": "^3.1.8",
     "@types/d3-time-format": "^4.0.3",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^25.9.0",
+    "@types/node": "^25.9.1",
     "@types/three": "^0.184.1",
-    "@typescript/native-preview": "7.0.0-dev.20260519.1",
-    "@vitest/coverage-v8": "4.1.5",
+    "@typescript/native-preview": "7.0.0-dev.20260527.2",
+    "@vitest/coverage-v8": "4.1.7",
     "@wooorm/starry-night": "^3.9.0",
     "happy-dom": "^20.9.0",
+    "knip": "^6.14.2",
     "mdsvex": "^0.12.7",
     "rehype-katex": "^7.0.1",
     "remark-math": "3.0.1",
-    "svelte": "5.55.8",
-    "svelte-check-rs": "0.9.13",
+    "svelte": "5.56.0",
+    "svelte-check-rs": "0.9.19",
     "typescript": "6.0.3",
-    "vite": "npm:@voidzero-dev/vite-plus-core@^0.1.21",
+    "vite": "^8.0.14",
     "vite-plus": "latest",
-    "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.21"
+    "vitest": "4.1.7"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"
   },
-  "overrides": {
-    "vite": "npm:@voidzero-dev/vite-plus-core@^0.1.21",
-    "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.21"
-  },
   "engines": {
     "node": ">=24"
   },
-  "packageManager": "pnpm@10.33.0"
+  "knip": {
+    "entry": [
+      "svelte.config.ts"
+    ],
+    "ignore": [
+      "extensions/**"
+    ],
+    "ignoreDependencies": [
+      "@typescript/native-preview",
+      "svelte-check-rs"
+    ]
+  }
 }