matterviz 0.3.5 → 0.3.7

package/dist/structure/bonding.js

@@ -2,17 +2,31 @@
 import { element_data } from '../element';
 import * as math from '../math';
 const element_lookup = new Map(element_data.map((el) => [el.symbol, el]));
-const covalent_radii = new Map(element_data
-    .filter((el) => el.covalent_radius !== null)
-    .map((el) => [el.symbol, el.covalent_radius]));
+const covalent_radii = new Map(element_data.flatMap((el) => el.covalent_radius === null ? [] : [[el.symbol, el.covalent_radius]]));
 const is_zero_cell_shift = (cell_shift) => cell_shift === undefined || cell_shift.every((val) => val === 0);
 const format_cell_shift = (cell_shift) => {
     if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
         return ``;
     return `@${cell_shift.join(`,`)}`;
 };
-const negate_cell_shift = (cell_shift) => cell_shift.map((val) => (val === 0 ? 0 : -val));
+const negate_cell_shift = (cell_shift) => [
+    cell_shift[0] === 0 ? 0 : -cell_shift[0],
+    cell_shift[1] === 0 ? 0 : -cell_shift[1],
+    cell_shift[2] === 0 ? 0 : -cell_shift[2],
+];
+const canonical_self_bond_shift = (cell_shift) => {
+    const first_non_zero = cell_shift.find((val) => val !== 0);
+    return first_non_zero !== undefined && first_non_zero < 0
+        ? negate_cell_shift(cell_shift)
+        : cell_shift;
+};
 const normalize_bond_endpoints = (site_idx_1, site_idx_2, cell_shift) => {
+    if (site_idx_1 === site_idx_2) {
+        const ordered = { site_idx_1, site_idx_2 };
+        if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
+            return ordered;
+        return { ...ordered, cell_shift: canonical_self_bond_shift(cell_shift) };
+    }
     const ordered = site_idx_1 < site_idx_2
         ? { site_idx_1, site_idx_2 }
         : { site_idx_1: site_idx_2, site_idx_2: site_idx_1 };
@@ -31,17 +45,174 @@ export const get_bond_key = (idx_1, idx_2, cell_shift) => {
     const normalized = normalize_bond_endpoints(idx_1, idx_2, cell_shift);
     return `${normalized.site_idx_1}-${normalized.site_idx_2}${format_cell_shift(normalized.cell_shift)}`;
 };
+export const BOND_ORDER_OPTIONS = [
+    { order: 1, label: `Single` },
+    { order: 1.5, label: `1.5` },
+    { order: 2, label: `Double` },
+    { order: 3, label: `Triple` },
+    { order: `aromatic`, label: `Aromatic` },
+];
+const site_image_shift = (sites, site_idx) => {
+    const site = sites?.[site_idx];
+    const orig_site_idx = site?.properties?.orig_site_idx;
+    if (typeof orig_site_idx !== `number`)
+        return [0, 0, 0];
+    const orig_site = sites?.[orig_site_idx];
+    if (!site?.abc || !orig_site?.abc)
+        return [0, 0, 0];
+    return [
+        Math.round(site.abc[0] - orig_site.abc[0]),
+        Math.round(site.abc[1] - orig_site.abc[1]),
+        Math.round(site.abc[2] - orig_site.abc[2]),
+    ];
+};
+const original_site_idx = (sites, site_idx) => {
+    const orig_site_idx = sites?.[site_idx]?.properties?.orig_site_idx;
+    return typeof orig_site_idx === `number` ? orig_site_idx : site_idx;
+};
+export const canonicalize_bond_target = (bond, sites) => {
+    const shift_1 = site_image_shift(sites, bond.site_idx_1);
+    const shift_2 = site_image_shift(sites, bond.site_idx_2);
+    const base_shift = bond.cell_shift ?? [0, 0, 0];
+    const cell_shift = [
+        base_shift[0] + shift_2[0] - shift_1[0],
+        base_shift[1] + shift_2[1] - shift_1[1],
+        base_shift[2] + shift_2[2] - shift_1[2],
+    ];
+    return normalize_bond_endpoints(original_site_idx(sites, bond.site_idx_1), original_site_idx(sites, bond.site_idx_2), cell_shift);
+};
+const bond_key_for = (bond) => get_bond_key(bond.site_idx_1, bond.site_idx_2, bond.cell_shift);
+const matches_bond_key = (bond, key) => bond_key_for(bond) === key;
+const replace_bond = (bonds, next_bond) => {
+    const key = bond_key_for(next_bond);
+    return [...bonds.filter((bond) => !matches_bond_key(bond, key)), next_bond];
+};
+const remove_bond_key = (bonds, key) => bonds.filter((bond) => !matches_bond_key(bond, key));
+const includes_bond_key = (bonds, key) => bonds.some((bond) => matches_bond_key(bond, key));
+const get_bond_order = (bond) => bond?.bond_order ?? bond?.order ?? 1;
+const find_bond_by_key = (bonds, key) => bonds.find((bond) => matches_bond_key(bond, key));
+const make_bond_record = (bond, order) => normalize_structure_bond(bond.site_idx_1, bond.site_idx_2, order, bond.cell_shift);
+export function has_visible_bond(edit_state, bond, calculated_bonds) {
+    const key = bond_key_for(bond);
+    if (includes_bond_key(edit_state.removed_bonds, key)) {
+        return false;
+    }
+    if (includes_bond_key(edit_state.added_bonds, key))
+        return true;
+    return includes_bond_key(calculated_bonds, key);
+}
+export function add_or_restore_bond(edit_state, bond, calculated_bonds, order) {
+    const record = make_bond_record(bond, order);
+    const key = bond_key_for(record);
+    const removed_bond = find_bond_by_key(edit_state.removed_bonds, key);
+    if (removed_bond) {
+        return {
+            action: `restored`,
+            changed: true,
+            state: {
+                ...edit_state,
+                added_bonds: remove_bond_key(edit_state.added_bonds, key),
+                removed_bonds: remove_bond_key(edit_state.removed_bonds, key),
+                bond_order_overrides: removed_bond.order === order
+                    ? remove_bond_key(edit_state.bond_order_overrides, key)
+                    : replace_bond(edit_state.bond_order_overrides, record),
+            },
+        };
+    }
+    if (has_visible_bond(edit_state, record, calculated_bonds)) {
+        return { action: `already-visible`, changed: false, state: edit_state };
+    }
+    return {
+        action: `added`,
+        changed: true,
+        state: {
+            ...edit_state,
+            added_bonds: replace_bond(edit_state.added_bonds, record),
+            bond_order_overrides: remove_bond_key(edit_state.bond_order_overrides, key),
+        },
+    };
+}
+export function delete_bond(edit_state, bond, calculated_bonds) {
+    const record = make_bond_record(bond, 1);
+    const key = bond_key_for(record);
+    if (includes_bond_key(edit_state.added_bonds, key)) {
+        return {
+            action: `deleted-added`,
+            changed: true,
+            state: {
+                ...edit_state,
+                added_bonds: remove_bond_key(edit_state.added_bonds, key),
+                bond_order_overrides: remove_bond_key(edit_state.bond_order_overrides, key),
+            },
+        };
+    }
+    const calculated = find_bond_by_key(calculated_bonds, key);
+    if (!calculated || includes_bond_key(edit_state.removed_bonds, key)) {
+        return { action: `not-visible`, changed: false, state: edit_state };
+    }
+    return {
+        action: `deleted-calculated`,
+        changed: true,
+        state: {
+            ...edit_state,
+            removed_bonds: replace_bond(edit_state.removed_bonds, {
+                ...record,
+                order: get_bond_order(calculated),
+            }),
+            bond_order_overrides: remove_bond_key(edit_state.bond_order_overrides, key),
+        },
+    };
+}
+export function set_bond_order(edit_state, bond, calculated_bonds, order) {
+    const record = make_bond_record(bond, order);
+    const key = bond_key_for(record);
+    const calculated = find_bond_by_key(calculated_bonds, key);
+    if (calculated) {
+        const visible_order = get_bond_order(calculated);
+        const has_existing_edit = includes_bond_key(edit_state.added_bonds, key) ||
+            includes_bond_key(edit_state.removed_bonds, key) ||
+            includes_bond_key(edit_state.bond_order_overrides, key);
+        const next_overrides = order === visible_order
+            ? remove_bond_key(edit_state.bond_order_overrides, key)
+            : replace_bond(edit_state.bond_order_overrides, record);
+        const next_state = {
+            added_bonds: remove_bond_key(edit_state.added_bonds, key),
+            removed_bonds: remove_bond_key(edit_state.removed_bonds, key),
+            bond_order_overrides: next_overrides,
+        };
+        return {
+            action: `ordered-calculated`,
+            changed: has_existing_edit || order !== visible_order,
+            state: next_state,
+        };
+    }
+    return {
+        action: `ordered-added`,
+        changed: true,
+        state: {
+            ...edit_state,
+            added_bonds: replace_bond(edit_state.added_bonds, record),
+            bond_order_overrides: remove_bond_key(edit_state.bond_order_overrides, key),
+        },
+    };
+}
 export const merge_bond_edits = (base_bonds, added, removed, overrides) => {
     const key_for = (bond) => get_bond_key(bond.site_idx_1, bond.site_idx_2, bond.cell_shift);
-    const merged = new Map(base_bonds.map((bond) => [key_for(bond), bond]));
-    for (const bond of removed)
-        merged.delete(key_for(bond));
+    const normalize_record = (bond) => normalize_structure_bond(bond.site_idx_1, bond.site_idx_2, bond.order, bond.cell_shift);
+    const removed_keys = new Set(removed.map(key_for));
+    const merged = new Map(base_bonds
+        .filter((bond) => !removed_keys.has(key_for(bond)))
+        .map((bond) => [key_for(bond), normalize_record(bond)]));
     // Apply additions before overrides so user-set bond orders win even if
     // callers accidentally pass overlapping edit lists.
-    for (const bond of added)
-        merged.set(key_for(bond), bond);
-    for (const bond of overrides)
-        merged.set(key_for(bond), bond);
+    for (const bond of added) {
+        if (!removed_keys.has(key_for(bond)))
+            merged.set(key_for(bond), normalize_record(bond));
+    }
+    for (const bond of overrides) {
+        if (!removed_keys.has(key_for(bond)))
+            merged.set(key_for(bond), normalize_record(bond));
+    }
     return [...merged.values()];
 };
 const is_record = (value) => typeof value === `object` && value !== null;
@@ -59,7 +230,7 @@ function normalize_cell_shift(cell_shift) {
         return null;
     return cell_shift.some((val) => typeof val !== `number` || !Number.isInteger(val))
         ? null
-        : cell_shift;
+        : [cell_shift[0], cell_shift[1], cell_shift[2]];
 }
 function lattice_translation(structure, cell_shift) {
     if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
@@ -123,10 +294,6 @@ export function get_explicit_bond_metadata(structure) {
             console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: site indices ${site_idx_1}, ${site_idx_2} are out of range for ${structure.sites.length} sites`);
             continue;
         }
-        if (site_idx_1 === site_idx_2) {
-            console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: endpoints match`);
-            continue;
-        }
         const bond_order = normalize_bond_order(order);
         if (bond_order === null) {
             console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: unsupported order ${String(order)}`);
@@ -137,6 +304,10 @@ export function get_explicit_bond_metadata(structure) {
             console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: cell_shift must be three integers`);
             continue;
         }
+        if (site_idx_1 === site_idx_2 && is_zero_cell_shift(cell_shift)) {
+            console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: endpoints match`);
+            continue;
+        }
         if (cell_shift !== undefined &&
             !is_zero_cell_shift(cell_shift) &&
             !(`lattice` in structure)) {

package/dist/structure/export.js

@@ -164,7 +164,7 @@ function convert_instanced_meshes_to_regular(scene) {
         // Check if this is a shader material (bonds)
         const mat = instanced_mesh.material;
         const is_shader = Array.isArray(mat)
-            ? mat.some((m) => m instanceof ShaderMaterial)
+            ? mat.some((material) => material instanceof ShaderMaterial)
             : mat instanceof ShaderMaterial;
         if (is_shader) {
             // Extract bond colors for each instance from geometry attributes

package/dist/structure/index.d.ts

@@ -3,9 +3,9 @@ import type { ElementSymbol } from '../element';
 import type { Vec3 } from '../math';
 import * as math from '../math';
 import type { ComponentProps } from 'svelte';
-import LatticeComponent from './Lattice.svelte';
+import type LatticeComponent from './Lattice.svelte';
 import type { Pbc } from './pbc';
-import StructureSceneComponent from './StructureScene.svelte';
+import type StructureSceneComponent from './StructureScene.svelte';
 export { default as Arrow } from './Arrow.svelte';
 export * from './atom-properties';
 export { default as AtomLegend } from './AtomLegend.svelte';
@@ -22,6 +22,7 @@ export { default as StructureInfoPane } from './StructureInfoPane.svelte';
 export { default as StructureScene } from './StructureScene.svelte';
 export * from './supercell';
 export type MeasureMode = `distance` | `angle` | `edit-bonds` | `edit-atoms`;
+export type BondEditMode = `add` | `delete`;
 export type Species = {
     element: ElementSymbol;
     occu: number;

package/dist/structure/index.js

@@ -1,8 +1,6 @@
 import { ATOMIC_WEIGHTS } from '../composition/parse';
 import { element_data } from '../element';
 import * as math from '../math';
-import LatticeComponent from './Lattice.svelte';
-import StructureSceneComponent from './StructureScene.svelte';
 export { default as Arrow } from './Arrow.svelte';
 export * from './atom-properties';
 export { default as AtomLegend } from './AtomLegend.svelte';

package/dist/structure/parse.js

@@ -4,6 +4,26 @@ import * as math from '../math';
 import { wrap_to_unit_cell } from './pbc';
 import { normalize_scientific_notation } from '../utils';
 import { load as yaml_load } from 'js-yaml';
+const cif_coords_key = (coords) => `${coords[0].toFixed(6)},${coords[1].toFixed(6)},${coords[2].toFixed(6)}`;
+const cif_site_key = (element, abc, label) => `${element}|${label}|${cif_coords_key(abc)}`;
+const clone_structure_properties = (properties) => structuredClone(properties);
+const FALLBACK_ELEMENTS = [`H`, `He`, `Li`, `Be`, `B`, `C`, `N`, `O`, `F`, `Ne`];
+const is_known_element_symbol = (symbol) => ELEM_SYMBOLS.includes(symbol);
+const vec3_from_values = (values, context) => {
+    if (values?.length !== 3) {
+        throw new Error(`Invalid ${context}: expected 3 coordinates, got ${values?.length ?? 0}`);
+    }
+    const coords = math.finite_vec3_from_values(values);
+    if (coords)
+        return coords;
+    for (let idx = 0; idx < 3; idx++) {
+        const value = values[idx];
+        if (typeof value !== `number` || !Number.isFinite(value)) {
+            throw new TypeError(`Invalid ${context}: coordinate ${idx} must be finite, got ${String(value)}`);
+        }
+    }
+    throw new Error(`Invalid ${context}: expected 3 finite coordinates`);
+};
 // Parse a coordinate value that might be in various scientific notation formats
 function parse_coordinate(str) {
     const normalized = normalize_scientific_notation(str.trim());
@@ -34,12 +54,10 @@ function parse_coordinate_line(line) {
 function validate_element_symbol(symbol, index) {
     // Clean symbol (remove suffixes like _pv, /hash)
     const clean_symbol = symbol.split(/[_/]/)[0];
-    if (ELEM_SYMBOLS && ELEM_SYMBOLS.includes(clean_symbol)) {
+    if (is_known_element_symbol(clean_symbol))
         return clean_symbol;
-    }
     // Fallback to default elements by atomic number
-    const fallback_elements = [`H`, `He`, `Li`, `Be`, `B`, `C`, `N`, `O`, `F`, `Ne`];
-    const fallback = fallback_elements[index % fallback_elements.length];
+    const fallback = FALLBACK_ELEMENTS[index % FALLBACK_ELEMENTS.length] ?? `H`;
     console.warn(`Invalid element symbol '${symbol}', using fallback '${fallback}'`);
     return fallback;
 }
@@ -73,10 +91,7 @@ export function parse_poscar(content) {
         // Parse lattice vectors (lines 3-5)
         const parse_vector = (line, line_num) => {
             const coords = line.trim().split(/\s+/).map(parse_coordinate);
-            if (coords.length !== 3) {
-                throw new Error(`Invalid lattice vector on line ${line_num}: expected 3 coordinates, got ${coords.length}`);
-            }
-            return coords;
+            return vec3_from_values(coords, `lattice vector on line ${line_num}`);
         };
         const lattice_vecs = [
             parse_vector(lines[2], 3),
@@ -168,7 +183,11 @@ export function parse_poscar(content) {
                 return null;
             }
             // Parse atomic positions
-            const poscar_axis_lengths = scaled_lattice.map((lattice_vec) => Math.hypot(...lattice_vec));
+            const poscar_axis_lengths = [
+                Math.hypot(...scaled_lattice[0]),
+                Math.hypot(...scaled_lattice[1]),
+                Math.hypot(...scaled_lattice[2]),
+            ];
             const poscar_frac_to_cart = math.create_frac_to_cart(scaled_lattice);
             const poscar_cart_to_frac = try_create_cart_to_frac(scaled_lattice);
             if (!is_direct && !poscar_cart_to_frac) {
@@ -185,7 +204,7 @@ export function parse_poscar(content) {
                         console.error(`Not enough coordinate lines in POSCAR`);
                         return null;
                     }
-                    const coords = parse_coordinate_line(lines[coord_line_idx]);
+                    const coords = vec3_from_values(parse_coordinate_line(lines[coord_line_idx]), `POSCAR atom coordinates on line ${coord_line_idx + 1}`);
                     // Parse selective dynamics if present
                     let selective_dynamics;
                     if (has_selective_dynamics) {
@@ -196,15 +215,14 @@ export function parse_poscar(content) {
                     }
                     let xyz;
                     let abc;
-                    const [x, y, z] = coords;
                     if (is_direct) {
                         // Store fractional coordinates, wrapping to [0, 1) range
-                        abc = wrap_to_unit_cell([x, y, z]);
+                        abc = wrap_to_unit_cell(coords);
                         xyz = poscar_frac_to_cart(abc);
                     }
                     else {
                         // Already Cartesian, scale if needed
-                        xyz = math.scale([x, y, z], scale_factor);
+                        xyz = math.scale(coords, scale_factor);
                         const raw_abc = poscar_cart_to_frac
                             ? poscar_cart_to_frac(xyz)
                             : approximate_cart_to_frac(xyz, poscar_axis_lengths);
@@ -288,9 +306,9 @@ export function parse_xyz(content) {
             const lattice_values = lattice_match[1].split(/\s+/).map(parse_coordinate);
             if (lattice_values.length === 9) {
                 const lattice_vectors = [
-                    [lattice_values[0], lattice_values[1], lattice_values[2]],
-                    [lattice_values[3], lattice_values[4], lattice_values[5]],
-                    [lattice_values[6], lattice_values[7], lattice_values[8]],
+                    vec3_from_values(lattice_values.slice(0, 3), `XYZ lattice vector 1`),
+                    vec3_from_values(lattice_values.slice(3, 6), `XYZ lattice vector 2`),
+                    vec3_from_values(lattice_values.slice(6, 9), `XYZ lattice vector 3`),
                 ];
                 const lattice_params = math.calc_lattice_params(lattice_vectors);
                 lattice = { matrix: lattice_vectors, ...lattice_params };
@@ -317,13 +335,7 @@ export function parse_xyz(content) {
                 return null;
             }
             const element = validate_element_symbol(parts[0], atom_idx);
-            const coords = [
-                parse_coordinate(parts[1]),
-                parse_coordinate(parts[2]),
-                parse_coordinate(parts[3]),
-            ];
-            // For XYZ files, coordinates are typically in Cartesian
-            const xyz = [coords[0], coords[1], coords[2]];
+            const xyz = vec3_from_values(parts.slice(1, 4).map(parse_coordinate), `XYZ atom position ${atom_idx + 1}`);
             // Calculate fractional coordinates if lattice is available
             let abc = [0, 0, 0];
             if (lattice && xyz_frac_to_cart && xyz_axis_lengths) {
@@ -430,10 +442,9 @@ const apply_symmetry_ops = (atom, symmetry_ops, wrap_fractional_coords) => {
     const wrap = (coords) => wrap_fractional_coords ? wrap_to_unit_cell(coords) : coords;
     // Use 6 decimal places for deduplication to handle floating point imprecision
     // from compound symmetry operations like x-y, -x+y which can produce small errors
-    const key = (coords) => `${coords[0].toFixed(6)},${coords[1].toFixed(6)},${coords[2].toFixed(6)}`;
     // Always include base atom (optionally wrapped)
     const base_coords = wrap(atom.coords);
-    seen.add(key(base_coords));
+    seen.add(cif_coords_key(base_coords));
     equivalent_atoms.push({ ...atom, coords: base_coords });
     for (const operation of symmetry_ops) {
         const operation_match = /['"]([^'"]+)['"]/.exec(operation);
@@ -453,7 +464,7 @@ const apply_symmetry_ops = (atom, symmetry_ops, wrap_fractional_coords) => {
         }
         // Wrap and deduplicate transformed coordinates
         const wrapped = wrap(new_coords);
-        const cache_key = key(wrapped);
+        const cache_key = cif_coords_key(wrapped);
         if (seen.has(cache_key))
             continue;
         seen.add(cache_key);
@@ -516,7 +527,7 @@ const parse_cif_atom_data = (raw_data, indices, coords_type) => {
     if (coord_indices.some((idx) => idx === undefined)) {
         throw new Error(`Missing coordinate indices`);
     }
-    const coords_triplet = coord_indices.map((idx) => {
+    const coords_triplet = vec3_from_values(coord_indices.map((idx) => {
         if (idx === undefined)
             throw new Error(`Invalid coordinate index`);
         const coord_str = raw_data[idx];
@@ -526,7 +537,7 @@ const parse_cif_atom_data = (raw_data, indices, coords_type) => {
         if (isNaN(coord))
             throw new Error(`Invalid coordinate: ${coord_str}`);
         return coord;
-    });
+    }), `CIF atom coordinates`);
     const occu = occupancy >= 0 && raw_data[occupancy]
         ? parseFloat(raw_data[occupancy].split(`(`)[0]) || 1.0
         : 1.0;
@@ -750,7 +761,6 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
         // Global deduplication of final sites (per element + coordinates + label)
         // Use 6 decimal places to handle floating point imprecision from compound symmetry ops
         const seen_site_keys = new Set();
-        const site_key = (element, abc, label) => `${element}|${label}|${abc[0].toFixed(6)},${abc[1].toFixed(6)},${abc[2].toFixed(6)}`;
         for (const atom of atoms) {
             const element = validate_element_symbol(atom.element, all_sites.length);
             // Convert to fractional coordinates if needed
@@ -779,7 +789,7 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
                         equiv_atom.coords[1] + cv[1],
                         equiv_atom.coords[2] + cv[2],
                     ]);
-                    const key = site_key(element, abc, equiv_atom.id);
+                    const key = cif_site_key(element, abc, equiv_atom.id);
                     if (seen_site_keys.has(key))
                         continue;
                     seen_site_keys.add(key);
@@ -806,12 +816,16 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
 function convert_phonopy_cell(cell) {
     const sites = [];
     // Phonopy stores lattice vectors as rows, use them directly
-    const lattice_matrix = cell.lattice;
+    const lattice_matrix = [
+        vec3_from_values(cell.lattice[0], `phonopy lattice vector 1`),
+        vec3_from_values(cell.lattice[1], `phonopy lattice vector 2`),
+        vec3_from_values(cell.lattice[2], `phonopy lattice vector 3`),
+    ];
     // Process each atomic site
     const phonopy_frac_to_cart = math.create_frac_to_cart(lattice_matrix);
     for (const point of cell.points) {
         const element = validate_element_symbol(point.symbol, sites.length);
-        const abc = [point.coordinates[0], point.coordinates[1], point.coordinates[2]];
+        const abc = vec3_from_values(point.coordinates, `phonopy point coordinates`);
         const xyz = phonopy_frac_to_cart(abc);
         const properties = {
             mass: point.mass,
@@ -825,6 +839,19 @@ function convert_phonopy_cell(cell) {
     const calculated_lattice_params = math.calc_lattice_params(lattice_matrix);
     return { sites, lattice: { matrix: lattice_matrix, ...calculated_lattice_params } };
 }
+const is_phonopy_cell = (value) => {
+    if (!value || typeof value !== `object`)
+        return false;
+    const lattice = `lattice` in value ? value.lattice : undefined;
+    const points = `points` in value ? value.points : undefined;
+    return Array.isArray(lattice) && Array.isArray(points);
+};
+const get_phonopy_cell = (data, cell_type) => {
+    if (!data || typeof data !== `object`)
+        return undefined;
+    const cell = Reflect.get(data, cell_type);
+    return is_phonopy_cell(cell) ? cell : undefined;
+};
 // Parse phonopy YAML file and return the requested cell type (or preferred single structure)
 export function parse_phonopy_yaml(content, cell_type) {
     try {
@@ -857,7 +884,7 @@ export function parse_phonopy_yaml(content, cell_type) {
         }
         // If specific cell type requested, parse only that one
         if (cell_type && cell_type !== `auto`) {
-            const cell = data[cell_type];
+            const cell = get_phonopy_cell(data, cell_type);
             if (cell)
                 return convert_phonopy_cell(cell);
             else {
@@ -871,17 +898,13 @@ export function parse_phonopy_yaml(content, cell_type) {
         // 3. unit_cell
         // 4. phonon_primitive_cell
         // 5. primitive_cell
-        if (data.supercell)
-            return convert_phonopy_cell(data.supercell);
-        else if (data.phonon_supercell)
-            return convert_phonopy_cell(data.phonon_supercell);
-        else if (data.unit_cell)
-            return convert_phonopy_cell(data.unit_cell);
-        else if (data.phonon_primitive_cell) {
-            return convert_phonopy_cell(data.phonon_primitive_cell);
-        }
-        else if (data.primitive_cell)
-            return convert_phonopy_cell(data.primitive_cell);
+        const auto_cell = get_phonopy_cell(data, `supercell`) ??
+            get_phonopy_cell(data, `phonon_supercell`) ??
+            get_phonopy_cell(data, `unit_cell`) ??
+            get_phonopy_cell(data, `phonon_primitive_cell`) ??
+            get_phonopy_cell(data, `primitive_cell`);
+        if (auto_cell)
+            return convert_phonopy_cell(auto_cell);
         console.error(`No valid cells found in phonopy YAML`);
         return null;
     }
@@ -924,17 +947,15 @@ function find_structure_in_json(obj, visited = new WeakSet()) {
 function is_parsed_structure(obj) {
     if (!obj || typeof obj !== `object`)
         return false;
-    const parsed_obj = obj;
-    const sites = parsed_obj.sites;
+    const sites = `sites` in obj ? obj.sites : undefined;
     if (!Array.isArray(sites) || sites.length === 0)
         return false;
     const first_site = sites[0];
     if (!first_site || typeof first_site !== `object`)
         return false;
-    const first_site_obj = first_site;
-    const species = first_site_obj.species;
-    const abc = first_site_obj.abc;
-    const xyz = first_site_obj.xyz;
+    const species = `species` in first_site ? first_site.species : undefined;
+    const abc = `abc` in first_site ? first_site.abc : undefined;
+    const xyz = `xyz` in first_site ? first_site.xyz : undefined;
     const has_species = Array.isArray(species) && species.length > 0;
     const has_coords = Array.isArray(abc) || Array.isArray(xyz);
     return has_species && has_coords;
@@ -1082,7 +1103,6 @@ export function parse_structure_file(content, filename) {
 }
 // Universal parser that handles JSON and structure files
 export function parse_any_structure(content, filename) {
-    const clone_structure_properties = (properties) => structuredClone(properties);
     const finalize_structure = (structure) => ({
         sites: structure.sites,
         charge: 0,
@@ -1145,7 +1165,13 @@ export function parse_optimade_from_raw(raw) {
         const positions = positions_raw;
         const species = species_raw;
         // Optimade stores lattice vectors as rows, so use as is
-        const lattice_matrix = attrs.lattice_vectors;
+        const lattice_matrix = attrs.lattice_vectors
+            ? [
+                vec3_from_values(attrs.lattice_vectors[0], `OPTIMADE lattice vector 1`),
+                vec3_from_values(attrs.lattice_vectors[1], `OPTIMADE lattice vector 2`),
+                vec3_from_values(attrs.lattice_vectors[2], `OPTIMADE lattice vector 3`),
+            ]
+            : undefined;
         const optimade_lattice_params = lattice_matrix
             ? math.calc_lattice_params(lattice_matrix)
             : null;
@@ -1168,12 +1194,15 @@ export function parse_optimade_from_raw(raw) {
         for (let idx = 0; idx < positions.length; idx++) {
             const pos = positions[idx];
             const element_symbol = species[idx];
-            if (!pos || pos.length < 3) {
-                console.warn(`Invalid position data at site ${idx}`);
+            let xyz;
+            try {
+                xyz = vec3_from_values(pos, `OPTIMADE site ${idx} position`);
+            }
+            catch (error) {
+                console.warn(`Invalid position data at site ${idx}: ${error}`);
                 continue;
             }
             const element = validate_element_symbol(element_symbol, idx);
-            const xyz = [pos[0], pos[1], pos[2]];
             // Calculate fractional coordinates if lattice is available
             const abc = optimade_cart_to_frac ? optimade_cart_to_frac(xyz) : [0, 0, 0];
             const site = {
@@ -1248,9 +1277,9 @@ export function optimade_to_crystal(optimade_structure) {
     }
     try {
         const lattice_matrix = [
-            lattice_vectors[0],
-            lattice_vectors[1],
-            lattice_vectors[2],
+            vec3_from_values(lattice_vectors[0], `OPTIMADE lattice vector 1`),
+            vec3_from_values(lattice_vectors[1], `OPTIMADE lattice vector 2`),
+            vec3_from_values(lattice_vectors[2], `OPTIMADE lattice vector 3`),
         ];
         const lattice_params = math.calc_lattice_params(lattice_matrix);
         // Build species lookup for site properties (mass, concentration, etc.)
@@ -1262,7 +1291,7 @@ export function optimade_to_crystal(optimade_structure) {
             if (!element_symbol)
                 throw new Error(`Missing species for site ${idx}`);
             const element = validate_element_symbol(element_symbol, idx);
-            const xyz = [pos[0], pos[1], pos[2]];
+            const xyz = vec3_from_values(pos, `OPTIMADE atom position ${idx + 1}`);
             const abc = crystal_cart_to_frac ? crystal_cart_to_frac(xyz) : [0, 0, 0];
             // Extract mass/concentration from species data
             const spec = species_map.get(element_symbol);

package/dist/symmetry/WyckoffTable.svelte

@@ -24,6 +24,13 @@
     `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${
       wyckoff_pos.site_indices?.join(`,`) ?? `none`
     }-${row_idx}`
+  $effect(() => {
+    if (!selected_key || wyckoff_positions?.some((pos, idx) => get_row_key(pos, idx) === selected_key)) {
+      return
+    }
+    selected_key = null
+    on_click?.(null)
+  })
 </script>
 
 {#if wyckoff_positions && wyckoff_positions.length > 0}