matterviz 0.4.2 → 0.4.3

package/dist/structure/format-detect.js

@@ -1,22 +1,20 @@
-import { CONFIG_DIRS_REGEX, STRUCT_KEYWORDS_REGEX, STRUCT_KEYWORDS_STRICT_REGEX, STRUCTURE_EXTENSIONS_REGEX, TRAJ_KEYWORDS_REGEX, VASP_FILES_REGEX, } from '../constants';
+import { CONFIG_DIRS_REGEX, STRUCT_KEYWORDS_REGEX, STRUCT_KEYWORDS_STRICT_REGEX, STRUCTURE_EXTENSIONS_REGEX, TRAJ_KEYWORDS_REGEX, VASP_FILES_REGEX, XDATCAR_REGEX, XYZ_EXTXYZ_REGEX, } from '../constants';
 import { strip_compression_extensions } from '../io/decompress';
 // Filename-only detection lives apart from the parsers so lightweight callers
 // (desktop recents, file pickers) do not load YAML, structure math, and element
 // data just to choose an icon.
 export function is_structure_file(filename) {
     const name = strip_compression_extensions(filename);
-    if (/\.(?:traj|xtc|h5|hdf5)$/i.test(name) || /xdatcar/i.test(name))
+    if (/\.(?:traj|xtc|h5|hdf5)$/i.test(name) || XDATCAR_REGEX.test(name))
         return false;
     if (STRUCTURE_EXTENSIONS_REGEX.test(name) || VASP_FILES_REGEX.test(name))
         return true;
-    if (/\.(?:xyz|extxyz)$/i.test(name))
+    if (XYZ_EXTXYZ_REGEX.test(name))
         return !TRAJ_KEYWORDS_REGEX.test(name);
     if (/\.(?:yaml|yml|xml)$/i.test(name) && STRUCT_KEYWORDS_REGEX.test(name))
         return true;
-    if (/\.json$/i.test(name) &&
+    return (/\.json$/i.test(name) &&
         STRUCT_KEYWORDS_STRICT_REGEX.test(name) &&
         !TRAJ_KEYWORDS_REGEX.test(name) &&
-        !CONFIG_DIRS_REGEX.test(name))
-        return true;
-    return false;
+        !CONFIG_DIRS_REGEX.test(name));
 }

package/dist/structure/index.js

@@ -1,5 +1,5 @@
 import { ATOMIC_WEIGHTS } from '../composition/parse';
-import { element_data } from '../element';
+import { element_by_symbol, element_data } from '../element';
 import * as math from '../math';
 export { default as Arrow } from './Arrow.svelte';
 export * from './atom-properties';
@@ -42,23 +42,17 @@ export function get_element_counts(structure) {
 export function format_chemical_formula(structure, sort_fn) {
     // concatenate elements in a structure followed by their amount
     const elements = get_element_counts(structure);
-    const formula = [];
-    for (const element of sort_fn(Object.keys(elements))) {
+    const formula = sort_fn(Object.keys(elements)).map((element) => {
         const amount = elements[element] ?? 0;
-        if (amount === 1)
-            formula.push(element);
-        else
-            formula.push(`${element}<sub>${amount}</sub>`);
-    }
+        return amount === 1 ? element : `${element}<sub>${amount}</sub>`;
+    });
     return formula.join(` `);
 }
-// Electronegativity by element symbol (0 when missing), for O(1) sort comparisons
-const electronegativity_by_symbol = new Map(element_data.map((el) => [el.symbol, el.electronegativity ?? 0]));
 export function format_formula_by_electronegativity(structure) {
     // concatenate elements in a structure followed by their amount sorted by electronegativity
     return format_chemical_formula(structure, (symbols) => symbols.sort((el1, el2) => {
-        const elec_neg1 = electronegativity_by_symbol.get(el1) ?? 0;
-        const elec_neg2 = electronegativity_by_symbol.get(el2) ?? 0;
+        const elec_neg1 = element_by_symbol.get(el1)?.electronegativity ?? 0;
+        const elec_neg2 = element_by_symbol.get(el2)?.electronegativity ?? 0;
         // Sort by electronegativity (ascending), then alphabetically for ties
         if (elec_neg1 !== elec_neg2)
             return elec_neg1 - elec_neg2;

package/dist/structure/parse.js

@@ -37,7 +37,6 @@ const aggregate_parse_error = (filename) => {
     return new Error(`Failed to parse structure${filename ? ` from '${filename}'` : ``}${detail}`);
 };
 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)}`;
 // Bravais lattice centering translations (excluding the identity) keyed by the
 // leading letter of a space-group Hermann-Mauguin symbol. R is the obverse
 // hexagonal setting.
@@ -72,15 +71,9 @@ const vec3_from_values = (values, context) => {
         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`);
+    if (!coords)
+        throw new Error(`Invalid ${context}: expected 3 finite coordinates, got [${values.map(String).join(`, `)}]`);
+    return coords;
 };
 // Parse a coordinate value that might be in various scientific notation formats
 function parse_coordinate(str) {
@@ -219,9 +212,9 @@ export function parse_poscar(content) {
         // Try to parse the first token as a number - if it succeeds, it's VASP 4 format
         const has_element_symbols = isNaN(parse_leading_num(lines[line_index]));
         if (has_element_symbols) {
-            // VASP 5+ format - parse element symbols (may span multiple lines)
+            // VASP 5+ format - element symbols (possibly spanning multiple lines),
+            // followed by as many atom-count lines. Look ahead to find where numbers start.
             let symbol_lines = 1;
-            // Look ahead to find where numbers start (atom counts)
             for (let lookahead_idx = 1; lookahead_idx < 10; lookahead_idx++) {
                 if (line_index + lookahead_idx >= lines.length)
                     break;
@@ -230,21 +223,11 @@ export function parse_poscar(content) {
                     break;
                 }
             }
-            // Collect all element symbols from the symbol lines
-            for (let symbol_line_idx = 0; symbol_line_idx < symbol_lines; symbol_line_idx++) {
-                if (line_index + symbol_line_idx < lines.length) {
-                    element_symbols.push(...lines[line_index + symbol_line_idx].trim().split(/\s+/));
-                }
-            }
-            // Parse atom counts (may span multiple lines)
-            for (let count_line_idx = 0; count_line_idx < symbol_lines; count_line_idx++) {
-                if (line_index + symbol_lines + count_line_idx < lines.length) {
-                    const counts = lines[line_index + symbol_lines + count_line_idx]
-                        .trim()
-                        .split(/\s+/)
-                        .map(Number);
-                    atom_counts.push(...counts);
-                }
+            for (let offset = 0; offset < symbol_lines; offset++) {
+                const symbol_tokens = lines[line_index + offset]?.trim().split(/\s+/) ?? [];
+                element_symbols.push(...symbol_tokens);
+                const count_tokens = lines[line_index + symbol_lines + offset]?.trim().split(/\s+/);
+                atom_counts.push(...(count_tokens?.map(Number) ?? []));
             }
             line_index += 2 * symbol_lines;
         }
@@ -393,17 +376,14 @@ export function parse_xyz(content) {
                 return null;
             }
             const element = validate_element_symbol(parts[0], atom_idx);
-            const xyz = vec3_from_values(parts.slice(1, 4).map(parse_coordinate), `XYZ atom position ${atom_idx + 1}`);
+            let 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_cart_to_frac) {
-                // Ensure fractional coordinates are wrapped into [0, 1) for consistency
+                // Wrap fractional coordinates into [0, 1) and recompute xyz from them so
+                // rendered atoms stay inside the primary unit cell
                 abc = wrap_to_unit_cell(xyz_cart_to_frac(xyz));
-                // Keep rendered atoms inside primary unit cell by recomputing xyz
-                const wrapped_xyz = xyz_frac_to_cart(abc);
-                xyz[0] = wrapped_xyz[0];
-                xyz[1] = wrapped_xyz[1];
-                xyz[2] = wrapped_xyz[2];
+                xyz = xyz_frac_to_cart(abc);
             }
             sites.push(make_site(element, abc, xyz, `${element}${atom_idx + 1}`));
         }
@@ -420,67 +400,31 @@ export function parse_xyz(content) {
 const parse_symmetry_expression = (expr_input) => {
     const coefficients = [0, 0, 0];
     let translation = 0;
-    // Remove all whitespace
+    // Strip whitespace, then split into signed terms: "x-y+1/3" → ["x", "-y", "+1/3"].
+    // Dangling operators (e.g. "x+") produce no token and are silently ignored.
     const expr = expr_input.replaceAll(/\s+/g, ``);
-    if (!expr)
-        return { coefficients, translation };
-    // Tokenize: split into terms while preserving signs
-    // E.g., "x-y+1/3" → ["x", "-y", "+1/3"] or "-x+y" → ["-x", "+y"]
-    const tokens = [];
-    let current_token = ``;
-    for (const char of expr) {
-        if ((char === `+` || char === `-`) && current_token.length > 0) {
-            tokens.push(current_token);
-            current_token = char;
-        }
-        else {
-            current_token += char;
-        }
-    }
-    if (current_token)
-        tokens.push(current_token);
-    for (const token of tokens) {
-        // Check if this token is a variable term (x, y, or z with optional sign)
-        const var_match = /^(?<sign>[+-]?)(?<axis>[xyz])$/.exec(token);
-        if (var_match) {
-            const sign = var_match[1] === `-` ? -1 : 1;
-            const var_char = var_match[2];
-            const var_idx = var_char === `x` ? 0 : var_char === `y` ? 1 : 2;
+    for (const token of expr.match(/[+-]?[^+-]+/g) ?? []) {
+        const sign = token.startsWith(`-`) ? -1 : 1;
+        const term = token.replace(/^[+-]/, ``);
+        // Variable term (x, y, or z)
+        const var_idx = [`x`, `y`, `z`].indexOf(term);
+        if (var_idx !== -1) {
             coefficients[var_idx] += sign;
             continue;
         }
-        // Check if this is a numeric term (integer, decimal, or fraction)
-        let sign = 1;
-        let num_str = token;
-        // Handle leading sign
-        if (num_str.startsWith(`+`)) {
-            num_str = num_str.slice(1);
-        }
-        else if (num_str.startsWith(`-`)) {
-            sign = -1;
-            num_str = num_str.slice(1);
-        }
-        // Skip empty tokens (from dangling operators like "x+")
-        if (!num_str || num_str === `+` || num_str === `-`)
+        // Numeric term: integer, decimal, or fraction like "1/3"
+        const parts = term.split(`/`);
+        // skip malformed terms like "1/2/3"
+        if (parts.length > 2) {
+            diag_warn(`Skipping malformed symmetry term '${term}'`);
             continue;
-        if (num_str.includes(`/`)) {
-            // Fraction
-            const parts = num_str.split(`/`);
-            if (parts.length === 2) {
-                const numerator = Number(parts[0]);
-                const denominator = Number(parts[1]);
-                if (!isNaN(numerator) && !isNaN(denominator) && denominator !== 0) {
-                    translation += sign * (numerator / denominator);
-                }
-            }
-        }
-        else {
-            // Integer or decimal
-            const val = Number(num_str);
-            if (!isNaN(val)) {
-                translation += sign * val;
-            }
         }
+        const [numerator, denominator = `1`] = parts;
+        const value = Number(numerator) / Number(denominator);
+        if (Number.isFinite(value))
+            translation += sign * value;
+        else
+            diag_warn(`Skipping non-finite symmetry term '${term}'`);
     }
     return { coefficients, translation };
 };
@@ -606,12 +550,9 @@ const split_cif_tokens = (line) => (line.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
 // Parse atom data from CIF with robust error handling
 const parse_cif_atom_data = (raw_data, indices, coords_type) => {
     const { label = 0, symbol = -1, occupancy = -1 } = indices;
+    // cif_coords_type already guaranteed all three indices for coords_type exist
     const coord_indices = cif_coord_indices(indices, coords_type);
-    if (coord_indices.some((idx) => idx === undefined)) {
-        throw new Error(`Missing coordinate indices`);
-    }
     const coords_triplet = vec3_from_values(coord_indices.map((idx) => {
-        // idx cannot be undefined: the `.some` guard above already threw
         const coord_str = raw_data[idx];
         if (!coord_str)
             throw new Error(`Missing coordinate at index ${idx}`);
@@ -623,8 +564,8 @@ const parse_cif_atom_data = (raw_data, indices, coords_type) => {
     const raw_occu = occupancy >= 0 && raw_data[occupancy]
         ? parse_cif_uncertain_number(raw_data[occupancy])
         : null;
-    // invalid or zero occupancy defaults to fully occupied
-    const occu = raw_occu == null || raw_occu === 0 ? 1.0 : raw_occu;
+    // Explicit 0 is kept; missing / `.` / `?` (null) default to fully occupied.
+    const occu = raw_occu ?? 1.0;
     const from_symbol = symbol >= 0 ? /^(?<element>[A-Z][a-z]*)/.exec(raw_data[symbol])?.[1] : undefined;
     const element_symbol = from_symbol ?? raw_data[label]?.match(/(?:[A-Z][a-z]*)/g)?.[0];
     if (!element_symbol) {
@@ -816,7 +757,7 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
                 const equiv_atoms = apply_symmetry_ops(fractional_atom, ops_to_use, wrap_fractional_coords, extra_centering);
                 for (const equiv_atom of equiv_atoms) {
                     const abc = wrap_vec3(equiv_atom.coords);
-                    const key = cif_site_key(element, abc, equiv_atom.id);
+                    const key = `${element}|${equiv_atom.id}|${cif_coords_key(abc)}`;
                     if (seen_site_keys.has(key))
                         continue;
                     seen_site_keys.add(key);
@@ -1321,10 +1262,7 @@ const unwrap_data = (value) => value && typeof value === `object` && `data` in v
 function is_optimade_structure_object(value) {
     if (!value || typeof value !== `object`)
         return false;
-    const obj = value;
-    const type = obj.type;
-    const id = obj.id;
-    const attributes = obj.attributes;
+    const { type, id, attributes } = value;
     return (type === `structures` &&
         typeof id === `string` &&
         typeof attributes === `object` &&

package/dist/structure/partial-occupancy.js

@@ -10,7 +10,6 @@ const make_render_site = (sites, site_idx, source_site_indices, site_override) =
     is_image_atom: source_site_indices.some((source_site_idx) => is_image_atom(sites[source_site_idx])),
     source_site_indices,
 });
-const sq_dist = (xyz_1, xyz_2) => (xyz_1[0] - xyz_2[0]) ** 2 + (xyz_1[1] - xyz_2[1]) ** 2 + (xyz_1[2] - xyz_2[2]) ** 2;
 const is_split_partial_site = (site, hidden_elements) => {
     const visible_species = site.species.filter(({ element }) => !hidden_elements.has(element));
     const total_visible_occupancy = visible_species.reduce((occupancy_sum, { occu }) => occupancy_sum + occu, 0);
@@ -25,7 +24,12 @@ const group_split_partial_indices = (sites, hidden_elements) => {
             non_grouped_site_indices.push(site_idx);
             continue;
         }
-        const matched_group_idx = grouped_centers.findIndex((center_xyz) => sq_dist(center_xyz, site.xyz) <= MERGE_DISTANCE_TOLERANCE ** 2);
+        const matched_group_idx = grouped_centers.findIndex((center_xyz) => {
+            const dx = center_xyz[0] - site.xyz[0];
+            const dy = center_xyz[1] - site.xyz[1];
+            const dz = center_xyz[2] - site.xyz[2];
+            return dx * dx + dy * dy + dz * dz <= MERGE_DISTANCE_TOLERANCE ** 2;
+        });
         if (matched_group_idx === -1) {
             grouped_centers.push(site.xyz);
             grouped_site_indices.push([site_idx]);
@@ -59,8 +63,7 @@ export const PARTIAL_OCCUPANCY_CAP_ARC = {
     arc_length: Math.PI,
 };
 export const merge_split_partial_sites = (sites, hidden_elements = new Set()) => {
-    const grouped_indices = group_split_partial_indices(sites, hidden_elements);
-    const { non_grouped_site_indices, grouped_site_indices } = grouped_indices;
+    const { non_grouped_site_indices, grouped_site_indices } = group_split_partial_indices(sites, hidden_elements);
     return build_render_sites(sites, non_grouped_site_indices, grouped_site_indices);
 };
 export const compute_slice_geometry = (visible_species, slice_gap_rad = PARTIAL_OCCUPANCY_SLICE_GAP_RAD) => {

package/dist/structure/pbc.js

@@ -1,5 +1,7 @@
+// Periodic boundary conditions utilities
+import { element_by_symbol } from '../element/data';
 import * as math from '../math';
-import { element_lookup, get_majority_element, has_framework_potential, is_spectator_center, pack_cell_key, } from './bonding';
+import { get_majority_element, has_framework_potential, is_spectator_center, pack_cell_key, } from './bonding';
 // Distance slack added to the covalent-radii sum when deciding whether a
 // candidate image atom bonds to a base atom (VESTA-like bond search criterion)
 const BOND_SLACK = 0.4; // Å
@@ -107,7 +109,7 @@ export function find_image_atoms(structure, { tolerance } = {}) {
     let max_radius = 0;
     for (const site of structure.sites) {
         const elem = get_majority_element(site);
-        const data = elem === null ? undefined : element_lookup.get(elem);
+        const data = elem === null ? undefined : element_by_symbol.get(elem);
         const radius = data?.covalent_radius ?? null;
         site_elements.push(elem);
         if (elem !== null)
@@ -250,17 +252,13 @@ export function find_image_atoms(structure, { tolerance } = {}) {
     }
     return image_sites;
 }
-// Return structure with image atoms added
+// Return structure with image atoms added (unchanged when none are generated,
+// e.g. for scattered trajectory-like data)
 export function get_pbc_image_sites(...args) {
     const structure = args[0];
-    if (!structure || !structure.sites || structure.sites.length === 0) {
-        return structure;
-    }
-    // Return trajectory data unchanged
-    if (is_scattered_trajectory(structure.sites))
-        return structure;
-    // Add image atoms to regular crystal structures
     const image_sites = find_image_atoms(...args);
+    if (image_sites.length === 0)
+        return structure;
     const imaged_struct = { ...structure, sites: [...structure.sites] };
     for (const [site_idx, img_xyz, img_abc, is_completion] of image_sites) {
         const orig_site = structure.sites[site_idx];

package/dist/structure/polyhedra.js

@@ -4,9 +4,10 @@
 // so the whole scene renders in 1-2 draw calls regardless of supercell size.
 // Hot paths use scalar math and per-element caches to scale to large structures.
 import { rgb as parse_rgb } from 'd3-color';
+import { element_by_symbol } from '../element/data';
 import { DEFAULTS } from '../settings';
 import { get_orig_site_idx } from './atom-properties';
-import { element_lookup, get_majority_element, has_framework_potential, is_spectator_center, } from './bonding';
+import { get_majority_element, has_framework_potential, is_spectator_center } from './bonding';
 const face_of = (points, vert_a, vert_b, vert_c) => {
     const [ax, ay, az] = points[vert_a];
     const abx = points[vert_b][0] - ax;
@@ -301,7 +302,7 @@ export function build_adjacency(bonds) {
 function is_anion_vertex(center_en, center_is_metal, neighbor_element, electronegativity_margin) {
     if (!neighbor_element)
         return false;
-    const n_data = element_lookup.get(neighbor_element);
+    const n_data = element_by_symbol.get(neighbor_element);
     if (n_data?.metal)
         return false;
     const n_en = n_data?.electronegativity ?? null;
@@ -341,12 +342,12 @@ export function compute_polyhedra(structure, bonds, options = {}) {
     const center_info = (element) => {
         let info = center_info_cache.get(element);
         if (!info) {
-            const data = element_lookup.get(element);
+            const data = element_by_symbol.get(element);
             const center_en = data?.electronegativity ?? null;
             const r_center = data?.covalent_radius ?? null;
             const accepts = new Set(unique_elements.filter((n_elem) => is_anion_vertex(center_en, data?.metal === true, n_elem, electronegativity_margin)));
             const radii_sums = new Map(unique_elements.map((n_elem) => {
-                const r_n = element_lookup.get(n_elem)?.covalent_radius ?? null;
+                const r_n = element_by_symbol.get(n_elem)?.covalent_radius ?? null;
                 return [n_elem, r_center !== null && r_n !== null ? r_center + r_n : null];
             }));
             info = { accepts, radii_sums };

package/dist/structure/prop-groups.d.ts

@@ -0,0 +1,85 @@
+import type { DefaultSettings } from '../settings';
+export declare const build_structure_props_from_settings: (defaults: DefaultSettings) => {
+    scene_props: {
+        gizmo: boolean;
+        atom_radius: number;
+        same_size_atoms: boolean;
+        show_atoms: boolean;
+        show_image_atoms: boolean;
+        sphere_segments: number;
+        bond_thickness: number;
+        auto_bond_order: boolean;
+        aromatic_display: "aromatic" | "kekule";
+        show_bonds: "always" | "never" | "crystals" | "molecules";
+        bond_color: string;
+        bonding_strategy: "electroneg_ratio" | "solid_angle";
+        show_polyhedra: "always" | "never" | "crystals" | "molecules";
+        polyhedra_opacity: number;
+        polyhedra_show_edges: boolean;
+        polyhedra_edge_color: string;
+        polyhedra_color_mode: import("./polyhedra").PolyhedraColorMode;
+        polyhedra_color: string;
+        polyhedra_hide_center_atoms: boolean;
+        polyhedra_min_neighbors: number;
+        polyhedra_max_neighbors: number;
+        polyhedra_excluded_elements: readonly string[];
+        polyhedra_included_elements: readonly string[];
+        atom_color_mode: "element" | "coordination" | "wyckoff" | "custom";
+        atom_color_scale: import("..").D3InterpolateName;
+        atom_color_scale_type: "continuous" | "categorical";
+        show_gizmo: boolean;
+        camera_position: import("..").Vec3;
+        camera_projection: import("../settings").CameraProjection;
+        initial_zoom: number;
+        fov: number;
+        rotation_damping: number;
+        rotate_speed: number;
+        zoom_speed: number;
+        pan_speed: number;
+        zoom_to_cursor: boolean;
+        max_zoom: number | undefined;
+        min_zoom: number | undefined;
+        auto_rotate: number;
+        rotation: import("..").Vec3;
+        show_site_labels: boolean;
+        show_site_indices: boolean;
+        site_label_size: number;
+        site_label_color: string;
+        site_label_bg_color: string;
+        site_label_padding: number;
+        site_label_offset: import("..").Vec3;
+        ambient_light: number;
+        directional_light: number;
+        vector_configs: Record<string, import("../settings").VectorLayerConfig>;
+        vector_scale: number;
+        vector_color: string;
+        vector_color_mode: "auto" | "element" | "uniform" | "spin_direction" | "magnitude";
+        vector_color_scale: import("..").D3InterpolateName;
+        vector_normalize: boolean;
+        vector_uniform_thickness: boolean;
+        vector_origin_gap: number;
+        vector_shaft_radius: number;
+        vector_arrow_head_radius: number;
+        vector_arrow_head_length: number;
+        show_cell: boolean;
+        show_cell_vectors: boolean;
+        cell_edge_opacity: number;
+        cell_surface_opacity: number;
+        cell_edge_color: string;
+        cell_surface_color: string;
+        cell_edge_width: number;
+        fullscreen_toggle: boolean;
+    };
+    lattice_props: {
+        cell_edge_opacity: number;
+        cell_surface_opacity: number;
+        cell_edge_color: string;
+        cell_surface_color: string;
+        cell_edge_width: number;
+        show_cell_vectors: boolean;
+    };
+    color_scheme: string;
+    background_color: string;
+    background_opacity: number;
+    show_image_atoms: boolean;
+};

package/dist/structure/prop-groups.js

@@ -0,0 +1,18 @@
+export const build_structure_props_from_settings = (defaults) => {
+    const { structure } = defaults;
+    return {
+        scene_props: { ...structure, gizmo: structure.show_gizmo },
+        lattice_props: {
+            cell_edge_opacity: structure.cell_edge_opacity,
+            cell_surface_opacity: structure.cell_surface_opacity,
+            cell_edge_color: structure.cell_edge_color,
+            cell_surface_color: structure.cell_surface_color,
+            cell_edge_width: structure.cell_edge_width,
+            show_cell_vectors: structure.show_cell_vectors,
+        },
+        color_scheme: defaults.color_scheme,
+        background_color: defaults.background_color,
+        background_opacity: defaults.background_opacity,
+        show_image_atoms: structure.show_image_atoms,
+    };
+};

package/dist/symmetry/SymmetryStats.svelte

@@ -95,14 +95,10 @@
     hermann_mauguin: `Hermann-Mauguin symbol describes symmetry operations. Format: Lattice type + Point group symmetry. Example: P4/mmm = Primitive + 4-fold rotation + mirror planes`,
     hall_number: `Hall number: alternative numbering system for space groups. Useful for crystallographic software compatibility.`,
     pearson_symbol: `Pearson symbol. Format: Crystal system + Number of atoms per unit cell. Example: tP2 = tetragonal primitive with 2 atoms`,
-    symmetry_operations: `Total symmetry operations that map the crystal structure onto itself. Includes rotations, translations, and combinations.`,
     distinct_orbits: `Number of unique Wyckoff positions (symmetry-equivalent atomic sites) in the crystal structure.`,
     wyckoff_sequence: `Wyckoff sequence: letters of all occupied Wyckoff positions in descending alphabetical order, with superscript counts for letters occupied by multiple orbits. A standard structure-type fingerprint (complements the Pearson symbol).`,
     free_params: `Internal degrees of freedom: number of free fractional-coordinate parameters (x, y, z in the ITA representative coordinates) summed over occupied Wyckoff orbits. 0 means all atomic positions are fully fixed by symmetry.`,
     settings: `All settings of this space group in the International Tables (origin choices, unique axes, cell choices, hexagonal vs rhombohedral axes). The setting detected for this structure is highlighted.`,
-    translations: `Number of translations in the crystal structure.`,
-    rotations: `Number of rotations in the crystal structure.`,
-    roto_translations: `Number of roto-translations in the crystal structure.`,
   }
   const tooltips: Record<string, string> = $derived(show_tooltips ? titles : {})
 

package/dist/symmetry/WyckoffTable.svelte

@@ -102,13 +102,13 @@
           <td>
             <span
               style:background-color={colors.element[elem]}
-              style="display: inline-block; padding: 0 6pt; border-radius: 3pt; line-height: 1.4"
+              style="display: inline-block; padding: 0 4pt; border-radius: 3pt; line-height: 1.25"
               {@attach contrast_color()}
             >
               {elem}
             </span>
           </td>
-          <td>({abc?.map(format_fractional).join(` , `) ?? `N/A`})</td>
+          <td>({abc?.map(format_fractional).join(`, `) ?? `N/A`})</td>
           {#if has_ita_coords}
             <td>{wyckoff_pos.coordinates ? `(${wyckoff_pos.coordinates})` : ``}</td>
           {/if}
@@ -136,10 +136,11 @@
 
 <style>
   .wyckoff-table {
-    margin-top: 1em;
+    margin-top: 0.5em;
+    border-collapse: collapse;
   }
   .wyckoff-table :is(th, td) {
-    padding: 2px 6px;
+    padding: 1px 3px;
     text-align: center;
     vertical-align: middle;
   }

package/dist/symmetry/cell-transform.js

@@ -19,10 +19,8 @@ original_structure) {
     // serialization for both input and output (see to_cell_json: column-major(B) ==
     // row-major(RB)), so the flat array is row-major with each row a lattice vector.
     const lattice_matrix = math.vec9_to_mat3x3([...cell.lattice.basis]);
-    // Calculate lattice parameters from matrix
     const lattice_params = math.calc_lattice_params(lattice_matrix);
     const frac_to_cart = math.create_frac_to_cart(lattice_matrix);
-    // Build sites from positions and atomic numbers
     const sites = cell.positions.map((abc, idx) => {
         const atomic_number = cell.numbers[idx];
         const element = ATOMIC_NUMBER_TO_SYMBOL[atomic_number];
@@ -31,11 +29,10 @@ original_structure) {
         }
         // Wrap fractional coordinates to [0, 1) range (moyo-wasm may return outside)
         const wrapped_abc = wrap_to_unit_cell(abc);
-        const xyz = frac_to_cart(wrapped_abc);
         // Oxidation state is set to 0 (unknown) because moyo-wasm only provides atomic numbers.
         // transformed cell may have different/reordered sites, making it non-trivial to
         // map oxidation states from original structure.
-        return make_site(element, wrapped_abc, xyz, element);
+        return make_site(element, wrapped_abc, frac_to_cart(wrapped_abc), element);
     });
     const lattice = {
         matrix: lattice_matrix,
@@ -55,14 +52,12 @@ original_structure) {
 // The conventional cell is the standard crystallographic setting for the space group.
 export function get_conventional_cell(original_structure, // The original input structure
 sym_data) {
-    // The conventional cell as a Crystal
     return moyo_cell_to_structure(sym_data.std_cell, original_structure);
 }
 // Get the primitive cell from symmetry analysis data.
 // The primitive cell is the smallest unit cell with one lattice point.
 export function get_primitive_cell(original_structure, // The original input structure
 sym_data) {
-    // The primitive cell as a Crystal
     return moyo_cell_to_structure(sym_data.prim_std_cell, original_structure);
 }
 // Transform a structure based on the selected cell type.
@@ -70,16 +65,12 @@ sym_data) {
 export function transform_cell(structure, // The original structure
 cell_type, // The desired cell type ('original', 'conventional', or 'primitive')
 sym_data) {
-    //transformed structure (or original if no transformation needed)
-    if (cell_type === `original` || !sym_data) {
+    if (!sym_data)
         return structure;
-    }
-    if (cell_type === `conventional`) {
+    if (cell_type === `conventional`)
         return get_conventional_cell(structure, sym_data);
-    }
-    if (cell_type === `primitive`) {
+    if (cell_type === `primitive`)
         return get_primitive_cell(structure, sym_data);
-    }
-    // Unknown cell_type at runtime (e.g. from stale persisted settings): leave unchanged
+    // 'original' or unknown runtime cell_type (e.g. stale persisted settings): unchanged
     return structure;
 }

package/dist/symmetry/index.js

@@ -89,10 +89,9 @@ function get_site_atomic_number(site, site_idx) {
             best_occupancy = occupancy;
         }
     });
-    if (selected_element === undefined) {
-        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
-    }
-    const atomic_number = SYMBOL_TO_ATOMIC_NUMBER[selected_element];
+    const atomic_number = selected_element
+        ? SYMBOL_TO_ATOMIC_NUMBER[selected_element]
+        : undefined;
     if (atomic_number === undefined) {
         throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
     }
@@ -233,13 +232,11 @@ function wyckoff_rows_from_input_orbits(sym_data) {
         };
     });
 }
-// Generate Wyckoff table rows from symmetry data by grouping moyo's input-cell sites into
-// crystallographic orbits. moyo's per-site arrays (wyckoffs, orbits, site_symmetry_symbols)
-// always index the input cell and analyze_structure_symmetry always attaches input_cell, so
-// the orbit grouping is the single source of truth for any input cell setting.
-// Rows sort by ascending multiplicity, then Wyckoff label.
 // Numeric multiplicity prefix of a Wyckoff label like `4a` (NaN when absent)
 export const wyckoff_multiplicity = (label) => Number(/^\d+/.exec(label)?.[0] ?? NaN);
+// Generate Wyckoff table rows from symmetry data via wyckoff_rows_from_input_orbits
+// (analyze_structure_symmetry always attaches the input_cell that grouping needs).
+// Rows sort by ascending multiplicity, then Wyckoff label.
 export function wyckoff_positions_from_moyo(sym_data) {
     if (!sym_data)
         return [];