matterviz 0.4.0 → 0.4.1

package/dist/spectral/helpers.js

@@ -1,6 +1,7 @@
 // Helper utilities for band structure and DOS data processing
 import { SUBSCRIPT_MAP } from '../labels';
-import { euclidean_dist } from '../math';
+import { is_plain_object } from '../utils';
+import { euclidean_dist, is_square_matrix } from '../math';
 const is_subscript_key = (key) => key in SUBSCRIPT_MAP;
 // 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) &&
@@ -204,7 +205,7 @@ export function normalize_densities(densities, freqs_or_energies, mode) {
         return normalized.map((dens) => dens / max_val);
     }
     else if (mode === `sum`) {
-        const sum = normalized.reduce((acc, d) => acc + d, 0);
+        const sum = normalized.reduce((acc, dens) => acc + dens, 0);
         if (sum === 0)
             return normalized;
         return normalized.map((dens) => dens / sum);
@@ -215,7 +216,7 @@ export function normalize_densities(densities, freqs_or_energies, mode) {
         const bin_width = freqs_or_energies[1] - freqs_or_energies[0];
         if (bin_width === 0)
             return normalized;
-        const sum = normalized.reduce((acc, d) => acc + d, 0);
+        const sum = normalized.reduce((acc, dens) => acc + dens, 0);
         if (sum === 0)
             return normalized;
         return normalized.map((dens) => dens / (sum * bin_width));
@@ -250,7 +251,7 @@ function generate_smearing_cache_key(freqs_or_energies, densities, sigma) {
 }
 // Core Gaussian smearing computation (unmemoized)
 function apply_gaussian_smearing_core(freqs_or_energies, densities, sigma) {
-    const orig_sum = densities.reduce((acc, d) => acc + d, 0);
+    const orig_sum = densities.reduce((acc, dens) => acc + dens, 0);
     if (sigma <= 0 || orig_sum === 0)
         return densities;
     const smeared = Array(densities.length).fill(0);
@@ -269,7 +270,7 @@ function apply_gaussian_smearing_core(freqs_or_energies, densities, sigma) {
         }
     }
     // Normalize to preserve integral
-    const smeared_sum = smeared.reduce((acc, d) => acc + d, 0);
+    const smeared_sum = smeared.reduce((acc, dens) => acc + dens, 0);
     if (smeared_sum === 0)
         return densities;
     const normalization = orig_sum / smeared_sum;
@@ -491,10 +492,9 @@ function convert_pymatgen_band_structure(pmg) {
         },
     };
 }
-export function normalize_band_structure(bs) {
-    if (!bs || typeof bs !== `object`)
+export function normalize_band_structure(band_struct) {
+    if (!is_plain_object(band_struct))
         return null;
-    const band_struct = bs;
     // Check if this is pymatgen format and convert if so
     if (is_pymatgen_format(band_struct)) {
         return convert_pymatgen_band_structure(band_struct);
@@ -516,27 +516,42 @@ export function normalize_band_structure(bs) {
             branch.end_index >= n_qpts ||
             branch.start_index > branch.end_index))
         return null;
-    return band_struct;
+    // Fill required defaults (recip_lattice/labels_dict/nb_bands) not covered above so the cast below is sound
+    const recip_lattice = band_struct.recip_lattice;
+    const normalized = {
+        ...band_struct,
+        nb_bands: typeof band_struct.nb_bands === `number` ? band_struct.nb_bands : bands.length,
+        labels_dict: band_struct.labels_dict ?? {},
+        recip_lattice: is_square_matrix(recip_lattice?.matrix, 3)
+            ? recip_lattice
+            : {
+                matrix: [
+                    [1, 0, 0],
+                    [0, 1, 0],
+                    [0, 0, 1],
+                ],
+            },
+    };
+    return normalized;
 }
 // Validate and normalize a DOS object.
 // Supports both matterviz and pymatgen formats.
 // Also auto-detects and converts cm⁻¹ to THz for legacy data (disable with auto_convert_units: false).
 export function normalize_dos(dos, options = {}) {
     const { auto_convert_units = true } = options;
-    if (!dos || typeof dos !== `object`)
+    if (!is_plain_object(dos))
         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 { frequencies, energies, spin_polarized } = dos_obj;
+    const is_pymatgen = typeof dos[`@class`] === `string` || typeof dos[`@module`] === `string`;
+    const { frequencies, energies, spin_polarized } = dos;
     // Handle densities as either array or dict with spin keys (pymatgen format)
     // Pymatgen stores densities as {1: [...], -1: [...]} or {"Spin.up": [...], ...}
-    const spin_channels = extract_spin_channels(dos_obj.densities);
+    const spin_channels = extract_spin_channels(dos.densities);
     if (!spin_channels)
         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.spin_down_densities ?? null;
     if (!Array.isArray(densities))
         return null;
     // Phonon DOS: has frequencies
@@ -743,13 +758,12 @@ export function find_qpoint_at_rescaled_x(band_struct, rescaled_x, x_positions)
 // Returns a dict of label → DosData for each atom or orbital.
 // filter_keys: optional list of keys to include (e.g., ["Fe", "O"] for atoms or ["s", "p", "d"] for orbitals)
 export function extract_pdos(dos, pdos_type, filter_keys) {
-    if (!dos || typeof dos !== `object`)
+    if (!is_plain_object(dos))
         return null;
-    const dos_obj = dos;
     // Get the appropriate projected DOS dict
     const pdos_dict = pdos_type === `atom`
-        ? dos_obj.atom_dos
-        : dos_obj.spd_dos;
+        ? dos.atom_dos
+        : dos.spd_dos;
     if (!pdos_dict || typeof pdos_dict !== `object`)
         return null;
     const result = {};
@@ -852,21 +866,15 @@ export function generate_ribbon_path(x_values, y_values, width_values, x_scale_f
 // Handles both single objects with an efermi field and dicts of objects.
 // Returns undefined if no valid efermi is found or if the source is empty.
 export function extract_efermi(data) {
-    if (!data || typeof data !== `object`)
+    if (!is_plain_object(data))
         return undefined;
-    const obj = data;
     // Direct efermi field on the object
-    if (`efermi` in obj && typeof obj.efermi === `number`)
-        return obj.efermi;
+    if (typeof data.efermi === `number`)
+        return data.efermi;
     // Dict of objects - try to get efermi from first value
-    const values = Object.values(obj);
-    if (values.length === 0)
-        return undefined;
-    const first_val = values[0];
-    if (first_val && typeof first_val === `object`) {
-        const efermi = first_val.efermi;
-        if (typeof efermi === `number`)
-            return efermi;
+    const first_val = Object.values(data)[0];
+    if (is_plain_object(first_val) && typeof first_val.efermi === `number`) {
+        return first_val.efermi;
     }
     return undefined;
 }
@@ -886,18 +894,16 @@ export function negative_fraction(values) {
 // Check if raw band structure input has electronic markers (efermi, kpoints, or electronic @class).
 // Must be called on raw input before normalization since these fields aren't preserved.
 function is_electronic_band_struct(bs) {
-    if (!bs || typeof bs !== `object`)
+    if (!is_plain_object(bs))
         return false;
-    const obj = bs;
     // Electronic band structures have efermi field
-    if (`efermi` in obj && typeof obj.efermi === `number`)
+    if (typeof bs.efermi === `number`)
         return true;
     // Pymatgen electronic format uses kpoints (not qpoints)
-    if (`kpoints` in obj && Array.isArray(obj.kpoints) && obj.kpoints.length > 0) {
+    if (Array.isArray(bs.kpoints) && bs.kpoints.length > 0)
         return true;
-    }
     // Pymatgen @class: BandStructure* but not Phonon*
-    const raw_class = obj[`@class`];
+    const raw_class = bs[`@class`];
     const py_class_name = typeof raw_class === `string` ? raw_class : ``;
     if (py_class_name.startsWith(`BandStructure`) && !py_class_name.includes(`Phonon`)) {
         return true;

package/dist/state.svelte.d.ts

@@ -1,6 +1,5 @@
 import type { ChemicalElement, ElementCategory } from './element/types';
 import { DEFAULT_CATEGORY_COLORS, default_element_colors } from './colors';
-import type { Tooltip } from './plot';
 import { type ThemeMode, type ThemeType } from './theme';
 export declare const selected: {
     category: ElementCategory | null;
@@ -12,12 +11,6 @@ export declare const colors: {
     category: typeof DEFAULT_CATEGORY_COLORS;
     element: typeof default_element_colors;
 };
-export declare const tooltip: Tooltip;
-export declare const periodic_table_state: {
-    show_bonding_info: boolean;
-    show_oxidation_state: boolean;
-    highlighted_elements: string[];
-};
 export declare const theme_state: {
     mode: ThemeMode;
     system_mode: ThemeType;

package/dist/state.svelte.js

@@ -11,12 +11,6 @@ export const colors = $state({
     category: { ...DEFAULT_CATEGORY_COLORS },
     element: { ...default_element_colors },
 });
-export const tooltip = $state({ show: false, x: 0, y: 0, title: ``, items: [] });
-export const periodic_table_state = $state({
-    show_bonding_info: false,
-    show_oxidation_state: false,
-    highlighted_elements: [],
-});
 // Theme state with safe initialization
 let initial_theme_mode = AUTO_THEME;
 let initial_system_mode = COLOR_THEMES.light;

package/dist/structure/Arrow.svelte

@@ -42,11 +42,9 @@
     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 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)) as Vec3,
+    math.add(position, math.scale(dir, shaft_len + head_len * 0.5)),
   )
 
   const rotation = $derived.by((): Vec3 => {

package/dist/structure/AtomLegend.svelte.d.ts

@@ -30,6 +30,6 @@ type $$ComponentProps = Omit<HTMLAttributes<HTMLDivElement>, `children`> & {
         structure?: AnyStructure | null;
     }]>;
 };
-declare const AtomLegend: import("svelte").Component<$$ComponentProps, {}, "labels" | "site_radius_overrides" | "atom_color_config" | "hidden_elements" | "hidden_prop_vals" | "element_radius_overrides" | "element_mapping">;
+declare const AtomLegend: import("svelte").Component<$$ComponentProps, {}, "labels" | "atom_color_config" | "hidden_elements" | "hidden_prop_vals" | "element_mapping" | "element_radius_overrides" | "site_radius_overrides">;
 type AtomLegend = ReturnType<typeof AtomLegend>;
 export default AtomLegend;

package/dist/structure/CanvasTooltip.svelte

@@ -19,6 +19,7 @@
 <style>
   div {
     width: max-content;
+    max-width: var(--canvas-tooltip-max-width, 16em);
     box-sizing: border-box;
     text-align: var(--canvas-tooltip-text-align, left);
     border-radius: var(--canvas-tooltip-border-radius, var(--border-radius, 3pt));

package/dist/structure/CellSelect.svelte

@@ -14,6 +14,7 @@
     loading = $bindable(false),
     direction = `down`,
     align = `right`,
+    suppress_hover = false,
   }: {
     supercell_scaling: string
     cell_type?: CellType
@@ -21,6 +22,7 @@
     loading?: boolean
     direction?: `up` | `down`
     align?: `left` | `right`
+    suppress_hover?: boolean // don't auto-open the menu on hover/focus (e.g. while a sibling popover is open)
   } = $props()
 
   let menu_open = $state(false)
@@ -80,20 +82,26 @@
       input_value = supercell_scaling
     }
   })
+
+  // Close + keep closed while suppressed so the menu can't obscure a sibling popover
+  // (e.g. the atom color-mode dropdown) the user is actively interacting with
+  $effect(() => {
+    if (suppress_hover) menu_open = false
+  })
 </script>
 
 <div
   class="cell-select"
   role="group"
   {@attach click_outside({ callback: () => (menu_open = false) })}
-  onmouseenter={() => (menu_open = true)}
+  onmouseenter={() => (menu_open = !suppress_hover)}
   onmouseleave={() => (menu_open = false)}
-  onfocusin={() => (menu_open = true)}
+  onfocusin={() => (menu_open = !suppress_hover)}
   onfocusout={handle_focus_out}
 >
   <button
     type="button"
-    onclick={() => (menu_open = !menu_open)}
+    onclick={() => (menu_open = !suppress_hover && !menu_open)}
     onkeydown={handle_key_down}
     class="toggle-btn"
     class:active={menu_open}

package/dist/structure/CellSelect.svelte.d.ts

@@ -7,7 +7,8 @@ type $$ComponentProps = {
     loading?: boolean;
     direction?: `up` | `down`;
     align?: `left` | `right`;
+    suppress_hover?: boolean;
 };
-declare const CellSelect: import("svelte").Component<$$ComponentProps, {}, "loading" | "supercell_scaling" | "cell_type">;
+declare const CellSelect: import("svelte").Component<$$ComponentProps, {}, "supercell_scaling" | "cell_type" | "loading">;
 type CellSelect = ReturnType<typeof CellSelect>;
 export default CellSelect;

package/dist/structure/Lattice.svelte

@@ -146,7 +146,7 @@
         {#each matrix as vec, idx (vec)}
           {@const shaft_length = Math.hypot(...vec) * 0.85}
           <!-- Shaft goes to 85% of vector length -->
-          {@const tip_start_position = math.scale(vec, 0.85) as Vec3}
+          {@const tip_start_position = math.scale(vec, 0.85)}
           <!-- Calculate rotation to align with vector direction -->
           {@const quaternion = new Quaternion().setFromUnitVectors(
       new Vector3(0, 1, 0), // Default up direction for cylinder/cone
@@ -157,7 +157,7 @@
       .toArray()
       .slice(0, 3) as Vec3}
           <!-- Arrow shaft - position at center of shaft length -->
-          {@const shaft_center = math.scale(vec, 0.425) as Vec3}
+          {@const shaft_center = math.scale(vec, 0.425)}
           <!-- Center at 42.5% = half of 85% -->
           <T.Mesh
             position={shaft_center}