matterviz 0.3.2 → 0.3.3

package/dist/spectral/helpers.js

@@ -1,6 +1,6 @@
 // Helper utilities for band structure and DOS data processing
 import { SUBSCRIPT_MAP } from '../labels';
-import { centered_frac, euclidean_dist, } from '../math';
+import { centered_frac, euclidean_dist } from '../math';
 // Check if range is a valid [min, max] tuple (strict 2-element array of finite numbers)
 export const is_valid_range = (range) => Array.isArray(range) &&
     range.length === 2 &&
@@ -70,7 +70,10 @@ export function pretty_sym_point(symbol) {
         .replace(/\\?SIGMA/gi, `Σ`)
         .replace(/\\?LAMBDA/gi, `Λ`)
         .replace(/(\p{L})(\d+)/gu, (_, letter, num) => letter +
-        num.split(``).map((digit) => SUBSCRIPT_MAP[digit] ?? digit).join(``));
+        num
+            .split(``)
+            .map((digit) => SUBSCRIPT_MAP[digit] ?? digit)
+            .join(``));
 }
 // Create segment key from start and end labels
 export const get_segment_key = (start_label, end_label) => `${start_label ?? `null`}_${end_label ?? `null`}`;
@@ -148,10 +151,10 @@ export function get_band_xaxis_ticks(band_struct, branches = []) {
 // Convert frequencies from THz to specified units.
 export function convert_frequencies(frequencies, unit = `THz`) {
     const conversion_factors = {
-        'THz': 1,
-        'eV': THz_TO_EV,
-        'meV': THz_TO_MEV,
-        'Ha': THz_TO_HA,
+        THz: 1,
+        eV: THz_TO_EV,
+        meV: THz_TO_MEV,
+        Ha: THz_TO_HA,
         'cm-1': THz_TO_CM,
     };
     const factor = conversion_factors[unit];
@@ -276,7 +279,9 @@ export function clear_smearing_cache() {
 }
 // Type guards for pymatgen qpoint formats
 const is_vec3 = (val) => Array.isArray(val) && val.length >= 3 && val.slice(0, 3).every(Number.isFinite);
-const is_kpoint = (val) => !!val && typeof val === `object` && `frac_coords` in val &&
+const is_kpoint = (val) => !!val &&
+    typeof val === `object` &&
+    `frac_coords` in val &&
     is_vec3(val.frac_coords);
 const is_pymatgen_format = (obj) => {
     // Check for explicit pymatgen markers
@@ -369,19 +374,24 @@ function convert_pymatgen_band_structure(pmg) {
     const labels_dict = pmg.labels_dict;
     const lattice_rec = pmg.lattice_rec;
     // Determine unit: cm-1 if frequencies_cm present, else check explicit unit or default to THz
-    const unit = pmg.unit?.toLowerCase() ??
-        (has_frequencies_cm ? `cm-1` : `thz`);
-    if (!Array.isArray(raw_qpts) || !Array.isArray(raw_bands) ||
-        !raw_qpts.length || !raw_bands.length)
+    const unit = pmg.unit?.toLowerCase() ?? (has_frequencies_cm ? `cm-1` : `thz`);
+    if (!Array.isArray(raw_qpts) ||
+        !Array.isArray(raw_bands) ||
+        !raw_qpts.length ||
+        !raw_bands.length)
         return null;
-    const qpoints = raw_qpts.map((q) => parse_qpoint(q, labels_dict)).filter((q) => q !== null);
+    const qpoints = raw_qpts
+        .map((q) => parse_qpoint(q, labels_dict))
+        .filter((q) => q !== null);
     if (!qpoints.length)
         return null;
     // Step distances and discontinuity detection (5x median threshold)
-    const steps = qpoints.slice(1).map((q, idx) => euclidean_dist(qpoints[idx].frac_coords, q.frac_coords));
+    const steps = qpoints
+        .slice(1)
+        .map((q, idx) => euclidean_dist(qpoints[idx].frac_coords, q.frac_coords));
     const sorted = steps.slice().sort((a, b) => a - b);
     const threshold = (sorted[Math.floor(sorted.length / 2)] ?? 0) * 5;
-    const disc_set = new Set(steps.map((s, idx) => s > threshold ? idx + 1 : -1).filter((i) => i >= 0));
+    const disc_set = new Set(steps.map((s, idx) => (s > threshold ? idx + 1 : -1)).filter((i) => i >= 0));
     // Cumulative distance (skip discontinuities)
     const distance = steps.reduce((acc, step, idx) => [...acc, disc_set.has(idx + 1) ? acc[idx] : acc[idx] + step], [0]);
     // Use pymatgen's branches if available - they correctly handle discontinuities
@@ -398,7 +408,7 @@ function convert_pymatgen_band_structure(pmg) {
     }
     // Fallback: infer branches from discontinuities when none provided or all invalid
     if (branches.length === 0) {
-        console.info(`Band structure missing 'branches' field - inferring from path discontinuities`);
+        console.warn(`Band structure missing 'branches' field - inferring from path discontinuities`);
         // Discontinuity indices mark points where the path jumps (disc before that index)
         // Create continuous segments between discontinuities
         const disc_indices = [...disc_set].sort((a, b) => a - b);
@@ -444,7 +454,13 @@ function convert_pymatgen_band_structure(pmg) {
         spin_down_bands: converted_spin_down_bands,
         nb_bands: raw_bands.length,
         labels_dict: labels_dict ?? {},
-        recip_lattice: { matrix: lattice_rec?.matrix ?? [[1, 0, 0], [0, 1, 0], [0, 0, 1]] },
+        recip_lattice: {
+            matrix: lattice_rec?.matrix ?? [
+                [1, 0, 0],
+                [0, 1, 0],
+                [0, 0, 1],
+            ],
+        },
     };
 }
 export function normalize_band_structure(bs) {
@@ -483,8 +499,7 @@ export function normalize_dos(dos, options = {}) {
         return null;
     const dos_obj = dos;
     // Check for pymatgen format (has @class or @module)
-    const is_pymatgen = typeof dos_obj[`@class`] === `string` ||
-        typeof dos_obj[`@module`] === `string`;
+    const is_pymatgen = typeof dos_obj[`@class`] === `string` || typeof dos_obj[`@module`] === `string`;
     const { frequencies, energies, spin_polarized } = dos_obj;
     // Handle densities as either array or dict with spin keys (pymatgen format)
     // Pymatgen stores densities as {1: [...], -1: [...]} or {"Spin.up": [...], ...}
@@ -493,8 +508,7 @@ export function normalize_dos(dos, options = {}) {
         return null;
     const densities = spin_channels.up;
     // Use extracted spin-down or fallback to explicit field (for already-normalized DosData)
-    const spin_down_densities = spin_channels.down ??
-        dos_obj.spin_down_densities ?? null;
+    const spin_down_densities = spin_channels.down ?? dos_obj.spin_down_densities ?? null;
     if (!Array.isArray(densities))
         return null;
     // Phonon DOS: has frequencies
@@ -509,7 +523,7 @@ export function normalize_dos(dos, options = {}) {
         if (auto_convert_units && max_freq > 100) {
             // Likely in cm⁻¹, convert to THz
             final_frequencies = frequencies.map((f) => f * CM_TO_THZ);
-            console.info(`Phonon DOS frequencies appear to be in cm⁻¹ (max: ${max_freq.toFixed(1)}). ` +
+            console.warn(`Phonon DOS frequencies appear to be in cm⁻¹ (max: ${max_freq.toFixed(1)}). ` +
                 `Converting to THz (max: ${(max_freq * CM_TO_THZ).toFixed(1)} THz).`);
         }
         return { type: `phonon`, frequencies: final_frequencies, densities };
@@ -525,9 +539,7 @@ export function normalize_dos(dos, options = {}) {
             type: `electronic`,
             energies,
             densities,
-            spin_down_densities: is_spin_polarized
-                ? spin_down_densities ?? undefined
-                : undefined,
+            spin_down_densities: is_spin_polarized ? (spin_down_densities ?? undefined) : undefined,
             spin_polarized: is_spin_polarized,
         };
     }
@@ -558,11 +570,10 @@ export function extract_k_path_points(band_struct, recip_lattice_matrix, options
             y = centered_frac(y);
             z = centered_frac(z);
         }
-        return [
-            x * m00 + y * m10 + z * m20,
-            x * m01 + y * m11 + z * m21,
-            x * m02 + y * m12 + z * m22,
-        ];
+        const kx = x * m00 + y * m10 + z * m20;
+        const ky = x * m01 + y * m11 + z * m21;
+        const kz = x * m02 + y * m12 + z * m22;
+        return [kx, ky, kz];
     });
 }
 // Find the q-point index closest to a given distance along the band structure path
@@ -638,7 +649,10 @@ export function find_qpoint_at_rescaled_x(band_struct, rescaled_x, x_positions)
         if (!segment_range)
             continue;
         const [x_start, x_end] = segment_range;
-        for (const [x_pos, idx] of [[x_start, start_idx], [x_end, end_idx]]) {
+        for (const [x_pos, idx] of [
+            [x_start, start_idx],
+            [x_end, end_idx],
+        ]) {
             const dist = Math.abs(rescaled_x - x_pos);
             if (dist < min_dist) {
                 min_dist = dist;
@@ -675,15 +689,12 @@ export function extract_pdos(dos, pdos_type, filter_keys) {
         const densities = spin_channels.up;
         if (!Array.isArray(densities) || energies.length !== densities.length)
             continue;
-        const is_spin_polarized = spin_channels.down !== null &&
-            spin_channels.down.length === densities.length;
+        const is_spin_polarized = spin_channels.down !== null && spin_channels.down.length === densities.length;
         result[key] = {
             type: `electronic`,
             energies,
             densities,
-            spin_down_densities: is_spin_polarized
-                ? spin_channels.down ?? undefined
-                : undefined,
+            spin_down_densities: is_spin_polarized ? (spin_channels.down ?? undefined) : undefined,
             spin_polarized: is_spin_polarized,
             efermi: nested_dos.efermi,
         };
@@ -743,9 +754,7 @@ export function generate_ribbon_path(x_values, y_values, width_values, x_scale_f
         const x_px = x_scale_fn(x_values[idx]);
         const y_data = y_values[idx];
         const raw_width = width_values[idx] ?? 0;
-        const width_normalized = Number.isFinite(raw_width) && raw_width > 0
-            ? raw_width / max_width_val
-            : 0;
+        const width_normalized = Number.isFinite(raw_width) && raw_width > 0 ? raw_width / max_width_val : 0;
         const half_width_px = width_normalized * max_width_px * scale;
         // In SVG, y increases downward, so upper edge has smaller y value
         const y_upper_px = y_scale_fn(y_data) - half_width_px;
@@ -757,7 +766,7 @@ export function generate_ribbon_path(x_values, y_values, width_values, x_scale_f
     const path_parts = [
         `M${upper_points[0]}`,
         ...upper_points.slice(1).map((pt) => `L${pt}`),
-        ...lower_points.reverse().map((pt) => `L${pt}`),
+        ...lower_points.toReversed().map((pt) => `L${pt}`),
         `Z`,
     ];
     return path_parts.join(` `);
@@ -811,7 +820,8 @@ function is_electronic_band_struct(bs) {
         return true;
     }
     // Pymatgen @class: BandStructure* but not Phonon*
-    const py_class_name = String(obj[`@class`] ?? ``);
+    const raw_class = obj[`@class`];
+    const py_class_name = typeof raw_class === `string` ? raw_class : ``;
     if (py_class_name.startsWith(`BandStructure`) && !py_class_name.includes(`Phonon`)) {
         return true;
     }
@@ -825,7 +835,8 @@ export function compute_frequency_range(band_structs, doses, padding_factor = 0.
     // (normalized structures always have qpoints, so we can't detect from them)
     let has_electronic_bs = false;
     // Support both qpoints (phonon) and kpoints (electronic) to detect single vs dict
-    const is_single_bs = band_structs && typeof band_structs === `object` &&
+    const is_single_bs = band_structs &&
+        typeof band_structs === `object` &&
         (`qpoints` in band_structs || `kpoints` in band_structs);
     if (band_structs && typeof band_structs === `object`) {
         // Single structure check
@@ -887,7 +898,8 @@ export function compute_frequency_range(band_structs, doses, padding_factor = 0.
     }
     if (!Number.isFinite(min_val) || !Number.isFinite(max_val))
         return undefined;
-    const clamp_min = is_phonon && min_val < 0 && // clamp phonon noise to 0
+    const clamp_min = is_phonon &&
+        min_val < 0 && // clamp phonon noise to 0
         negative_fraction(all_freqs) < IMAGINARY_MODE_NOISE_THRESHOLD;
     if (clamp_min)
         min_val = 0;
@@ -897,7 +909,7 @@ export function compute_frequency_range(band_structs, doses, padding_factor = 0.
 }
 // Parse axis label: "Frequency (THz)" → { name: "Frequency", unit: "THz" }
 function parse_axis_label(label) {
-    const match = label.match(/^(.+?)\s*\(([^)]+)\)$/);
+    const match = /^(.+?)\s*\(([^)]+)\)$/.exec(label);
     return match ? { name: match[1], unit: match[2] } : { name: label };
 }
 // Format DOS tooltip content from axis labels and values

package/dist/state.svelte.d.ts

@@ -1,7 +1,7 @@
 import type { ChemicalElement, ElementCategory } from './element/types';
 import { DEFAULT_CATEGORY_COLORS, default_element_colors } from './colors';
 import type { Tooltip } from './plot';
-import type { ThemeMode, ThemeType } from './theme';
+import { type ThemeMode, type ThemeType } from './theme';
 export declare const selected: {
     category: ElementCategory | null;
     element: ChemicalElement | null;

package/dist/state.svelte.js

@@ -1,5 +1,6 @@
 import { AUTO_THEME, COLOR_THEMES, THEME_TYPE } from './theme/index';
 import { DEFAULT_CATEGORY_COLORS, default_element_colors } from './colors';
+import { is_valid_theme_mode } from './theme';
 export const selected = $state({
     category: null,
     element: null,
@@ -22,8 +23,8 @@ let initial_system_mode = COLOR_THEMES.light;
 // Safe theme initialization for test environments
 try {
     if (typeof window !== `undefined` && globalThis.localStorage) {
-        initial_theme_mode = localStorage.getItem(`matterviz-theme`) ||
-            AUTO_THEME;
+        const saved_theme = localStorage.getItem(`matterviz-theme`) ?? ``;
+        initial_theme_mode = is_valid_theme_mode(saved_theme) ? saved_theme : AUTO_THEME;
     }
     else {
         initial_theme_mode = AUTO_THEME;

package/dist/structure/Arrow.svelte

@@ -1,23 +1,62 @@
-<script lang="ts">import * as math from '../math';
-import { DEFAULTS } from '../settings';
-import { T } from '@threlte/core';
-import { Euler, Quaternion, Vector3 } from 'three';
-let { position, vector, scale = DEFAULTS.structure.force_scale, color = DEFAULTS.structure.force_color, shaft_radius = DEFAULTS.structure.force_shaft_radius, arrow_head_radius = DEFAULTS.structure.force_arrow_head_radius, arrow_head_length = DEFAULTS.structure.force_arrow_head_length, ...rest } = $props();
-const mag = $derived(Math.hypot(...vector));
-const dir = $derived(mag > math.EPS ? math.scale(vector, 1 / mag) : [0, 1, 0]);
-const vec_len = $derived(mag * scale);
-const head_len = $derived(arrow_head_length < 0 ? vec_len * -arrow_head_length : arrow_head_length);
-const shaft_len = $derived(Math.max(0, vec_len - head_len * 0.5));
-const shaft_r = $derived(shaft_radius < 0 ? shaft_len * -shaft_radius : shaft_radius);
-const head_r = $derived(arrow_head_radius < 0 ? shaft_len * -arrow_head_radius : arrow_head_radius);
-const shaft_pos = $derived(math.add(position, math.scale(dir, shaft_len * 0.5)));
-const head_pos = $derived(math.add(position, math.scale(dir, shaft_len + head_len * 0.5)));
-const rotation = $derived.by(() => {
-    if (mag < math.EPS)
-        return [0, 0, 0];
-    const quat = new Quaternion().setFromUnitVectors(new Vector3(0, 1, 0), new Vector3(...dir));
-    return new Euler().setFromQuaternion(quat).toArray().slice(0, 3);
-});
+<script lang="ts">
+  import type { Vec3 } from '../math'
+  import * as math from '../math'
+  import { DEFAULTS } from '../settings'
+  import { T } from '@threlte/core'
+  import type { ComponentProps } from 'svelte'
+  import { Euler, Quaternion, Vector3 } from 'three'
+
+  let {
+    position,
+    vector,
+    scale = DEFAULTS.structure.vector_scale,
+    color = DEFAULTS.structure.vector_color,
+    shaft_radius = DEFAULTS.structure.vector_shaft_radius,
+    arrow_head_radius = DEFAULTS.structure.vector_arrow_head_radius,
+    arrow_head_length = DEFAULTS.structure.vector_arrow_head_length,
+    ...rest
+  }: ComponentProps<typeof T.Mesh> & {
+    position: Vec3
+    vector: Vec3
+    scale?: number
+    color?: string
+    shaft_radius?: number // negative = relative to length
+    arrow_head_radius?: number
+    arrow_head_length?: number
+  } = $props()
+
+  const mag = $derived(Math.hypot(...vector))
+  const dir = $derived(
+    mag > math.EPS ? math.scale(vector, 1 / mag) : ([0, 1, 0] as Vec3),
+  )
+  const vec_len = $derived(mag * scale)
+
+  const head_len = $derived(
+    arrow_head_length < 0 ? vec_len * -arrow_head_length : arrow_head_length,
+  )
+  const shaft_len = $derived(Math.max(0, vec_len - head_len * 0.5))
+  const shaft_r = $derived(
+    shaft_radius < 0 ? shaft_len * -shaft_radius : shaft_radius,
+  )
+  const head_r = $derived(
+    arrow_head_radius < 0 ? shaft_len * -arrow_head_radius : arrow_head_radius,
+  )
+
+  const shaft_pos = $derived(
+    math.add(position, math.scale(dir, shaft_len * 0.5)) as Vec3,
+  )
+  const head_pos = $derived(
+    math.add(position, math.scale(dir, shaft_len + head_len * 0.5)) as Vec3,
+  )
+
+  const rotation = $derived.by((): Vec3 => {
+    if (mag < math.EPS) return [0, 0, 0]
+    const quat = new Quaternion().setFromUnitVectors(
+      new Vector3(0, 1, 0),
+      new Vector3(...dir),
+    )
+    return new Euler().setFromQuaternion(quat).toArray().slice(0, 3) as Vec3
+  })
 </script>
 
 {#if shaft_len > 0.01}