matterviz 0.3.2 → 0.3.4

package/dist/structure/supercell.js

@@ -1,9 +1,6 @@
 import * as math from '../math';
-// Wrap fractional coordinates to [0, 1) range, clamping near-1 values to 0
-const wrap_frac = (coord) => {
-    const wrapped = ((coord % 1) + 1) % 1;
-    return wrapped >= 1 - 1e-10 ? 0 : wrapped;
-};
+import { scale_lattice_matrix } from '../math';
+import { wrap_frac_coord } from './pbc';
 // Parse supercell scaling input from various formats. Can be "2x2x2", "2", [2,2,2], or a single number.
 // Returns [x, y, z] scaling factors.
 export function parse_supercell_scaling(scaling) {
@@ -21,7 +18,11 @@ export function parse_supercell_scaling(scaling) {
     }
     if (typeof scaling === `string`) {
         // Parse "2x2x2" format
-        const parts = scaling.trim().toLowerCase().split(/[x×,\s]+/).filter((part) => part.length > 0);
+        const parts = scaling
+            .trim()
+            .toLowerCase()
+            .split(/[x×,\s]+/)
+            .filter((part) => part.length > 0);
         if (parts.length === 1 || parts.length === 3) {
             // Check that all parts are strictly digits to avoid scientific notation/hex/etc per tests
             if (parts.every((part) => /^\d+$/.test(part))) {
@@ -51,19 +52,8 @@ export function generate_lattice_points(scaling_factors) {
     }
     return points;
 }
-// Scale a lattice matrix by supercell factors
-// Takes original 3x3 lattice matrix and [scale_x, scale_y, scale_z] scaling factors
-// Returns new scaled lattice matrix
-export function scale_lattice_matrix(orig_matrix, scaling_factors) {
-    const [nx, ny, nz] = scaling_factors;
-    const [a, b, c] = orig_matrix;
-    // Scale each lattice vector by its corresponding factor
-    return [
-        [a[0] * nx, a[1] * nx, a[2] * nx],
-        [b[0] * ny, b[1] * ny, b[2] * ny],
-        [c[0] * nz, c[1] * nz, c[2] * nz],
-    ];
-}
+// Re-export from $lib/math for backward compatibility
+export { scale_lattice_matrix };
 // Create a supercell from a Crystal
 // Takes original structure, scaling factors, and whether to fold coordinates back to unit cell (default: true)
 // Returns new supercell structure
@@ -111,9 +101,9 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
                     let new_b = (site.abc[1] + jj) / sy;
                     let new_c = (site.abc[2] + kk) / sz;
                     if (to_unit_cell) {
-                        new_a = wrap_frac(new_a);
-                        new_b = wrap_frac(new_b);
-                        new_c = wrap_frac(new_c);
+                        new_a = wrap_frac_coord(new_a);
+                        new_b = wrap_frac_coord(new_b);
+                        new_c = wrap_frac_coord(new_c);
                     }
                     new_sites[write_idx++] = {
                         species: site.species,

package/dist/structure/validation.js

@@ -5,7 +5,6 @@ export function is_crystal(obj) {
     const sites = structure_obj.sites;
     const lattice = structure_obj.lattice;
     const has_sites = Array.isArray(sites) && sites.length > 0;
-    const has_lattice = lattice !== undefined && lattice !== null &&
-        typeof lattice === `object`;
+    const has_lattice = lattice !== undefined && lattice !== null && typeof lattice === `object`;
     return has_sites && has_lattice;
 }

package/dist/symmetry/SymmetryStats.svelte

@@ -1,49 +1,92 @@
-<script lang="ts">import { tooltip } from 'svelte-multiselect';
-import { SETTINGS_CONFIG } from '../settings';
-import { default_sym_settings, wyckoff_positions_from_moyo } from './index';
-import * as spg from './spacegroups';
-let { sym_data, settings = $bindable(default_sym_settings), show_tooltips = true, children, label = `Symmetry`, header, ...rest } = $props();
-const wyckoff_count = $derived(sym_data ? wyckoff_positions_from_moyo(sym_data).length : 0);
-const display_hm_symbol = $derived(sym_data?.hm_symbol?.replace(/\s+/g, ``) ?? `?`);
-const sym_ops_counts = $derived.by(() => {
-    const EPS = 1e-10;
+<script lang="ts">
+  import type { MoyoDataset } from '@spglib/moyo-wasm'
+  import type { Snippet } from 'svelte'
+  import { tooltip } from 'svelte-multiselect'
+  import type { HTMLAttributes } from 'svelte/elements'
+  import { SETTINGS_CONFIG } from '../settings'
+  import type { SymmetrySettings } from './index'
+  import { default_sym_settings, wyckoff_positions_from_moyo } from './index'
+  import * as spg from './spacegroups'
+
+  type SymmetrySnippet = Snippet<
+    [{ sym_data?: MoyoDataset | null; settings: SymmetrySettings }]
+  >
+
+  let {
+    sym_data,
+    settings = $bindable(default_sym_settings),
+    show_tooltips = true,
+    children,
+    label = `Symmetry`,
+    header,
+    ...rest
+  }: HTMLAttributes<HTMLDivElement> & {
+    sym_data?: MoyoDataset | null
+    settings?: SymmetrySettings
+    show_tooltips?: boolean
+    children?: SymmetrySnippet
+    label?: SymmetrySnippet | string
+    header?: SymmetrySnippet
+  } = $props()
+
+  const wyckoff_count = $derived(
+    sym_data ? wyckoff_positions_from_moyo(sym_data).length : 0,
+  )
+  const display_hm_symbol = $derived(sym_data?.hm_symbol?.replace(/\s+/g, ``) ?? `?`)
+
+  const sym_ops_counts = $derived.by(() => {
+    const EPS = 1e-10
     if (!sym_data?.operations) {
-        return { translations: 0, rotations: 0, roto_translations: 0 };
+      return { translations: 0, rotations: 0, roto_translations: 0 }
     }
-    return sym_data.operations.reduce((acc, op) => {
-        const has_translation = op.translation.some((coord) => Math.abs(coord) > EPS);
-        const is_identity = String(op.rotation) === `1,0,0,0,1,0,0,0,1`;
-        if (is_identity && has_translation)
-            acc.translations++;
-        else if (!has_translation)
-            acc.rotations++;
-        else
-            acc.roto_translations++;
-        return acc;
-    }, { translations: 0, rotations: 0, roto_translations: 0 });
-});
-const titles = {
-    symprec: `Symmetry precision control in spglib/moyo. Lower values (e.g. 1e-4, the default) are more strict, higher values (e.g. 1e-1) are more tolerant of numerical errors in atomic positions.`,
-    algo: `Symmetry detection algorithm: Moyo uses moyo's newer recommended settings, Spglib is useful if you need compatible results to an existing set of spglib-detected symmetries.`,
-    space_group: `International Tables Space group number (1-230) - unique identifier for each space group. Higher numbers indicate more symmetries in the crystal.`,
-    crystal_system: `Crystal system classification based on the unit cell symmetry. Seven systems: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, and cubic.`,
-    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.`,
+
+    return sym_data.operations.reduce(
+      (acc, op) => {
+        const has_translation = op.translation.some((coord) => Math.abs(coord) > EPS)
+        const is_identity = String(op.rotation) === `1,0,0,0,1,0,0,0,1`
+
+        if (is_identity && has_translation) acc.translations++
+        else if (!has_translation) acc.rotations++
+        else acc.roto_translations++
+
+        return acc
+      },
+      { translations: 0, rotations: 0, roto_translations: 0 },
+    )
+  })
+
+  const titles = {
+    symprec:
+      `Symmetry precision control in spglib/moyo. Lower values (e.g. 1e-4, the default) are more strict, higher values (e.g. 1e-1) are more tolerant of numerical errors in atomic positions.`,
+    algo:
+      `Symmetry detection algorithm: Moyo uses moyo's newer recommended settings, Spglib is useful if you need compatible results to an existing set of spglib-detected symmetries.`,
+    space_group:
+      `International Tables Space group number (1-230) - unique identifier for each space group. Higher numbers indicate more symmetries in the crystal.`,
+    crystal_system:
+      `Crystal system classification based on the unit cell symmetry. Seven systems: triclinic, monoclinic, orthorhombic, tetragonal, trigonal, hexagonal, and cubic.`,
+    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.`,
     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 = $derived(show_tooltips ? titles : {});
-function get_step_from_order_of_magnitude(value) {
-    if (!Number.isFinite(value) || value <= 0)
-        return 1e-5;
-    const exponent = Math.floor(Math.log10(value));
-    return Math.pow(10, exponent);
-}
-const symprec_step = $derived(get_step_from_order_of_magnitude(settings.symprec));
+  }
+  const tooltips: Record<string, string> = $derived(show_tooltips ? titles : {})
+
+  function get_step_from_order_of_magnitude(value: number): number {
+    if (!Number.isFinite(value) || value <= 0) return 1e-5
+    const exponent = Math.floor(Math.log10(value))
+    return Math.pow(10, exponent)
+  }
+
+  const symprec_step = $derived(get_step_from_order_of_magnitude(settings.symprec))
 </script>
 
 <div {...rest} class="symmetry-stats {rest.class ?? ``}">

package/dist/symmetry/WyckoffTable.svelte

@@ -1,9 +1,29 @@
-<script lang="ts">import { contrast_color } from '../colors';
-import { format_fractional } from '../labels';
-import { colors } from '../state.svelte';
-let { wyckoff_positions, on_hover, on_click, active_color = `#2563eb`, ...rest } = $props();
-let selected_key = $state(null);
-const get_row_key = (wyckoff_pos, row_idx) => `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${wyckoff_pos.site_indices?.join(`,`) ?? `none`}-${row_idx}`;
+<script lang="ts">
+  import { contrast_color } from '../colors'
+  import { format_fractional } from '../labels'
+  import { colors } from '../state.svelte'
+  import type { HTMLAttributes } from 'svelte/elements'
+  import type { WyckoffPos } from '.'
+
+  let {
+    wyckoff_positions,
+    on_hover,
+    on_click,
+    active_color = `#2563eb`,
+    ...rest
+  }: HTMLAttributes<HTMLTableElement> & {
+    wyckoff_positions: WyckoffPos[]
+    on_hover?: (site_indices: number[] | null) => void
+    on_click?: (site_indices: number[] | null) => void
+    active_color?: string
+  } = $props()
+
+  let selected_key = $state<string | null>(null)
+
+  const get_row_key = (wyckoff_pos: WyckoffPos, row_idx: number) =>
+    `${wyckoff_pos.wyckoff}-${wyckoff_pos.elem}-${
+      wyckoff_pos.site_indices?.join(`,`) ?? `none`
+    }-${row_idx}`
 </script>
 
 {#if wyckoff_positions && wyckoff_positions.length > 0}

package/dist/symmetry/cell-transform.js

@@ -19,7 +19,7 @@ original_structure) {
     ];
     // Calculate lattice parameters from matrix
     const lattice_params = math.calc_lattice_params(lattice_matrix);
-    const lattice_T = math.transpose_3x3_matrix(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];
@@ -29,8 +29,7 @@ original_structure) {
         }
         // Wrap fractional coordinates to [0, 1) range (moyo-wasm may return outside)
         const wrapped_abc = wrap_to_unit_cell(abc);
-        // Convert fractional to Cartesian: xyz = lattice_T · abc
-        const xyz = math.mat3x3_vec3_multiply(lattice_T, wrapped_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.
@@ -48,12 +47,14 @@ 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.
@@ -61,6 +62,7 @@ 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) {
         return structure;
     }

package/dist/symmetry/index.js

@@ -38,8 +38,7 @@ function get_site_atomic_number(site, site_idx) {
             continue;
         occupancy_by_element.set(element, (occupancy_by_element.get(element) ?? 0) + occu);
     }
-    let selected_element = site
-        .species[0]?.element;
+    let selected_element = site.species[0]?.element;
     let best_occupancy = -Infinity;
     occupancy_by_element.forEach((occupancy, element) => {
         if (occupancy > best_occupancy ||
@@ -49,11 +48,11 @@ function get_site_atomic_number(site, site_idx) {
         }
     });
     if (selected_element === undefined) {
-        throw new Error(`Unknown element at site ${site_idx}: ${String(selected_element)}`);
+        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
     }
     const atomic_number = SYMBOL_TO_ATOMIC_NUMBER[selected_element];
     if (atomic_number === undefined) {
-        throw new Error(`Unknown element at site ${site_idx}: ${String(selected_element)}`);
+        throw new Error(`Unknown element at site ${site_idx}: ${selected_element}`);
     }
     return atomic_number;
 }
@@ -122,7 +121,9 @@ export function simplicity_score(vec) {
     const near_zero = (v) => Math.min(v, 1 - v);
     const near_half = (v) => Math.abs(v - 0.5);
     const [ax, ay, az] = vec?.map(to_unit) ?? [];
-    return (near_zero(ax) + near_zero(ay) + near_zero(az) +
+    return (near_zero(ax) +
+        near_zero(ay) +
+        near_zero(az) +
         0.5 * (near_half(ax) + near_half(ay) + near_half(az)));
 }
 // Generate Wyckoff table rows from symmetry data
@@ -138,7 +139,7 @@ export function wyckoff_positions_from_moyo(sym_data) {
     for (let idx = 0; idx < numbers.length; idx++) {
         // Use wyckoff letter if available, otherwise mark as non-symmetric
         const full = idx < wyckoffs.length ? wyckoffs[idx] : null;
-        const letter = (full?.match(/[a-z]+$/)?.[0] ?? full ?? ``).toString();
+        const letter = full?.match(/[a-z]+$/)?.[0] ?? full ?? ``;
         const atomic_num = numbers[idx];
         const elem = ATOMIC_NUMBER_TO_SYMBOL[atomic_num] ?? `?`;
         const position = positions[idx];
@@ -206,7 +207,7 @@ export function map_wyckoff_to_all_atoms(wyckoff_positions, displayed_structure,
     const periodic_distance = (pos1, pos2) => Math.sqrt(pos1.reduce((sum, coord, idx) => {
         // Wrap delta into [-0.5, 0.5) using safe modulo
         const delta = coord - pos2[idx];
-        const wrapped = (((delta + 0.5) % 1) + 1) % 1 - 0.5;
+        const wrapped = ((((delta + 0.5) % 1) + 1) % 1) - 0.5;
         const d = Math.abs(wrapped);
         return sum + d * d;
     }, 0));