matterviz 0.3.4 → 0.3.5

package/dist/structure/bonding.js

@@ -5,6 +5,215 @@ 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 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 normalize_bond_endpoints = (site_idx_1, site_idx_2, 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 };
+    if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
+        return ordered;
+    return {
+        ...ordered,
+        cell_shift: site_idx_1 < site_idx_2 ? cell_shift : negate_cell_shift(cell_shift),
+    };
+};
+export const normalize_structure_bond = (site_idx_1, site_idx_2, order, cell_shift) => {
+    const bond = normalize_bond_endpoints(site_idx_1, site_idx_2, cell_shift);
+    return { ...bond, order };
+};
+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 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));
+    // 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);
+    return [...merged.values()];
+};
+const is_record = (value) => typeof value === `object` && value !== null;
+export function normalize_bond_order(order) {
+    if (order === `aromatic`)
+        return order;
+    if (order === 1 || order === 1.5 || order === 2 || order === 3)
+        return order;
+    return null;
+}
+function normalize_cell_shift(cell_shift) {
+    if (cell_shift === undefined)
+        return undefined;
+    if (!Array.isArray(cell_shift) || cell_shift.length !== 3)
+        return null;
+    return cell_shift.some((val) => typeof val !== `number` || !Number.isInteger(val))
+        ? null
+        : cell_shift;
+}
+function lattice_translation(structure, cell_shift) {
+    if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
+        return [0, 0, 0];
+    if (!(`lattice` in structure)) {
+        throw new Error(`Explicit bond cell_shift requires a crystal lattice`);
+    }
+    const [shift_a, shift_b, shift_c] = cell_shift;
+    const [vec_a, vec_b, vec_c] = structure.lattice.matrix;
+    return math.add(math.scale(vec_a, shift_a), math.scale(vec_b, shift_b), math.scale(vec_c, shift_c));
+}
+export function structure_bond_to_bond_pair(structure, bond) {
+    const { site_idx_1, site_idx_2, order, cell_shift } = bond;
+    const site_1 = structure.sites[site_idx_1];
+    const site_2 = structure.sites[site_idx_2];
+    if (!site_1 || !site_2) {
+        throw new Error(`Cannot create bond pair for invalid site indices ${site_idx_1}, ${site_idx_2}`);
+    }
+    const pos_1 = site_1.xyz;
+    const pos_2 = math.add(site_2.xyz, lattice_translation(structure, cell_shift));
+    return {
+        pos_1,
+        pos_2,
+        site_idx_1,
+        site_idx_2,
+        bond_length: math.euclidean_dist(pos_1, pos_2),
+        strength: 1,
+        bond_order: order,
+        cell_shift,
+        transform_matrix: compute_bond_transform(pos_1, pos_2),
+    };
+}
+export function get_explicit_bond_metadata(structure) {
+    const raw_bonds = structure.properties?.bonds;
+    if (raw_bonds === undefined)
+        return [];
+    if (!Array.isArray(raw_bonds)) {
+        console.warn(`Ignoring structure.properties.bonds because it is not an array`);
+        return [];
+    }
+    const explicit_bonds = new Map();
+    for (const [entry_idx, raw_bond] of raw_bonds.entries()) {
+        if (!is_record(raw_bond)) {
+            console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: expected object`);
+            continue;
+        }
+        const { order } = raw_bond;
+        const site_idx_1 = raw_bond.site_idx_1;
+        const site_idx_2 = raw_bond.site_idx_2;
+        if (typeof site_idx_1 !== `number` ||
+            typeof site_idx_2 !== `number` ||
+            !Number.isInteger(site_idx_1) ||
+            !Number.isInteger(site_idx_2)) {
+            console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: site indices must be integers`);
+            continue;
+        }
+        if (site_idx_1 < 0 ||
+            site_idx_2 < 0 ||
+            site_idx_1 >= structure.sites.length ||
+            site_idx_2 >= structure.sites.length) {
+            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)}`);
+            continue;
+        }
+        const cell_shift = normalize_cell_shift(raw_bond.cell_shift);
+        if (cell_shift === null) {
+            console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: cell_shift must be three integers`);
+            continue;
+        }
+        if (cell_shift !== undefined &&
+            !is_zero_cell_shift(cell_shift) &&
+            !(`lattice` in structure)) {
+            console.warn(`Ignoring invalid explicit bond at index ${entry_idx}: cell_shift requires a crystal lattice`);
+            continue;
+        }
+        const key = get_bond_key(site_idx_1, site_idx_2, cell_shift);
+        if (explicit_bonds.has(key)) {
+            console.warn(`Duplicate explicit bond definition at index ${entry_idx} for site indices ${site_idx_1}, ${site_idx_2} with order ${bond_order}; will overwrite the previous entry`);
+        }
+        explicit_bonds.set(key, normalize_structure_bond(site_idx_1, site_idx_2, bond_order, cell_shift));
+    }
+    return [...explicit_bonds.values()];
+}
+export function apply_explicit_bond_metadata(structure, bonds) {
+    const explicit_bonds = get_explicit_bond_metadata(structure);
+    if (explicit_bonds.length === 0)
+        return bonds;
+    const explicit_by_key = new Map(explicit_bonds.map((bond) => [
+        get_bond_key(bond.site_idx_1, bond.site_idx_2, bond.cell_shift),
+        bond,
+    ]));
+    const merged = bonds.map((bond) => {
+        const key = get_bond_key(bond.site_idx_1, bond.site_idx_2, bond.cell_shift);
+        const explicit = explicit_by_key.get(key);
+        if (!explicit)
+            return bond;
+        explicit_by_key.delete(key);
+        return { ...bond, bond_order: explicit.order };
+    });
+    for (const explicit_bond of explicit_by_key.values()) {
+        merged.push(structure_bond_to_bond_pair(structure, explicit_bond));
+    }
+    return merged;
+}
+export function scale_and_offset_bond_matrix(transform_matrix, offset, radius_scale) {
+    const matrix = new Float32Array(transform_matrix);
+    // Column-major 4x4 layout: 0-2 are the right vector, 8-10 are the forward
+    // vector. Scale orientation columns for cylinder radius, not translation.
+    for (const matrix_idx of [0, 1, 2, 8, 9, 10]) {
+        matrix[matrix_idx] *= radius_scale;
+    }
+    const right_len = Math.hypot(matrix[0], matrix[1], matrix[2]) || 1;
+    const offset_dir = [
+        matrix[0] / right_len,
+        matrix[1] / right_len,
+        matrix[2] / right_len,
+    ];
+    matrix[12] += offset_dir[0] * offset;
+    matrix[13] += offset_dir[1] * offset;
+    matrix[14] += offset_dir[2] * offset;
+    return matrix;
+}
+export function get_bond_render_matrices(bond, bond_thickness) {
+    const order = bond.bond_order ?? 1;
+    const gap = bond_thickness * 1.8;
+    const offsets_and_scales = order === 2
+        ? [
+            [-gap / 2, 0.65],
+            [gap / 2, 0.65],
+        ]
+        : order === 3
+            ? [
+                [-gap, 0.55],
+                [0, 0.55],
+                [gap, 0.55],
+            ]
+            : order === 1.5 || order === `aromatic`
+                ? [
+                    [-gap / 2, 0.75],
+                    [gap / 2, 0.4],
+                ]
+                : [];
+    return offsets_and_scales.length === 0
+        ? [bond.transform_matrix]
+        : offsets_and_scales.map(([offset, radius_scale]) => scale_and_offset_bond_matrix(bond.transform_matrix, offset, radius_scale));
+}
 // Get the species with highest occupancy from a site.
 const get_majority_species = (site) => (site.species ?? []).reduce((max_species, species) => (species.occu > max_species.occu ? species : max_species), site.species?.[0] ?? { element: ``, occu: -1 });
 // Helper to extract numeric index from site properties
@@ -70,10 +279,22 @@ export function compute_bond_transform(pos_1, pos_2) {
     ];
     return new Float32Array([
         // Return flattened column-major 4x4 matrix for Three.js
-        ...[m00, m10, m20, 0],
-        ...[m01 * height, m11 * height, m21 * height, 0],
-        ...[m02, m12, m22, 0],
-        ...[px, py, pz, 1],
+        m00,
+        m10,
+        m20,
+        0,
+        m01 * height,
+        m11 * height,
+        m21 * height,
+        0,
+        m02,
+        m12,
+        m22,
+        0,
+        px,
+        py,
+        pz,
+        1,
     ]);
 }
 // Build spatial grid by dividing 3D space into cubic cells.
@@ -175,7 +396,7 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
             if (dist > expected * max_distance_ratio)
                 continue;
             const electroneg_diff = Math.abs(props_a.electroneg - props_b.electroneg);
-            const electroneg_ratio = electroneg_diff / (props_a.electroneg + props_b.electroneg);
+            const electroneg_balance = electroneg_diff / (props_a.electroneg + props_b.electroneg);
             let bond_strength = 1.0;
             if (props_a.is_metal && props_b.is_metal) {
                 bond_strength *= metal_metal_penalty;
@@ -190,7 +411,7 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
                 bond_strength *= similar_electronegativity_bonus;
             }
             const dist_weight = Math.exp(-((dist / expected - 1) ** 2) / 0.18);
-            const electroneg_weight = 1.0 - 0.3 * electroneg_ratio;
+            const electroneg_weight = 1.0 - 0.3 * electroneg_balance;
             let strength = bond_strength * dist_weight * electroneg_weight;
             if (props_a.element === props_b.element)
                 strength *= same_species_penalty;
@@ -248,7 +469,7 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
             });
         }
     }
-    return bonds;
+    return apply_explicit_bond_metadata(structure, bonds);
 }
 // Solid angle-based bonding using geometric proximity heuristics.
 // Inspired by Voronoi tessellation without having to actually compute Voronoi cells.
@@ -281,11 +502,11 @@ export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area =
             }
             const avg_radius = (radius_a + radius_b) / 2.0;
             const face_area = Math.PI * avg_radius * avg_radius;
-            const solid_angle = face_area / dist_sq;
-            if (solid_angle < min_solid_angle || face_area < min_face_area)
+            const bond_solid_angle = face_area / dist_sq;
+            if (bond_solid_angle < min_solid_angle || face_area < min_face_area)
                 continue;
             const dist_penalty = Math.exp(-((dist / (radius_a + radius_b) - 1) ** 2) / 0.4);
-            const angle_strength = Math.min(solid_angle / (4.0 * Math.PI), 1.0);
+            const angle_strength = Math.min(bond_solid_angle / (4.0 * Math.PI), 1.0);
             const strength = angle_strength * dist_penalty;
             if (strength > strength_threshold) {
                 bonds.push({
@@ -300,5 +521,5 @@ export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area =
             }
         }
     }
-    return bonds;
+    return apply_explicit_bond_metadata(structure, bonds);
 }

package/dist/structure/export.js

@@ -467,11 +467,13 @@ export function structure_to_cif_str(structure) {
         structure.symmetry &&
         typeof structure.symmetry === `object`) {
         const symmetry = structure.symmetry;
-        if (`space_group_symbol` in symmetry && symmetry.space_group_symbol) {
-            lines.push(`_space_group_name_H-M_alt ${symmetry.space_group_symbol}`);
+        const { space_group_number, space_group_symbol } = symmetry;
+        if (typeof space_group_symbol === `string` && space_group_symbol) {
+            lines.push(`_space_group_name_H-M_alt ${space_group_symbol}`);
         }
-        if (`space_group_number` in symmetry && symmetry.space_group_number) {
-            lines.push(`_space_group_IT_number ${symmetry.space_group_number}`);
+        if ((typeof space_group_number === `number` || typeof space_group_number === `string`) &&
+            space_group_number) {
+            lines.push(`_space_group_IT_number ${space_group_number}`);
         }
     }
     lines.push(``);

package/dist/structure/index.d.ts

@@ -2,9 +2,10 @@ import type { CompositionType } from '../composition';
 import type { ElementSymbol } from '../element';
 import type { Vec3 } from '../math';
 import * as math from '../math';
-import type { Lattice, StructureScene } from './';
 import type { ComponentProps } from 'svelte';
+import LatticeComponent from './Lattice.svelte';
 import type { Pbc } from './pbc';
+import StructureSceneComponent from './StructureScene.svelte';
 export { default as Arrow } from './Arrow.svelte';
 export * from './atom-properties';
 export { default as AtomLegend } from './AtomLegend.svelte';
@@ -46,12 +47,22 @@ export type Molecule = {
     sites: Site[];
     charge?: number;
     id?: string;
-    properties?: Record<string, unknown>;
+    properties?: StructureProperties;
 };
 export type Crystal = Molecule & {
     lattice: LatticeType;
 };
 export type AnyStructure = Crystal | Molecule;
+export type BondOrder = 1 | 1.5 | 2 | 3 | `aromatic`;
+export type StructureBond = {
+    site_idx_1: number;
+    site_idx_2: number;
+    order: BondOrder;
+    cell_shift?: Vec3;
+};
+export type StructureProperties = Record<string, unknown> & {
+    bonds?: StructureBond[];
+};
 export type BondPair = {
     pos_1: Vec3;
     pos_2: Vec3;
@@ -59,8 +70,12 @@ export type BondPair = {
     site_idx_2: number;
     bond_length: number;
     strength: number;
+    bond_order?: BondOrder;
+    cell_shift?: Vec3;
     transform_matrix: Float32Array;
 };
+export type { PerceivedBond, PerceptionOptions } from './bond-order-perception';
+export { compose_perceived_bonds, perceive_bond_orders, } from './bond-order-perception';
 export declare function get_element_counts(structure: AnyStructure): Partial<Record<"S" | "K" | "B" | "H" | "He" | "Li" | "Be" | "C" | "N" | "O" | "F" | "Ne" | "Na" | "Mg" | "Al" | "Si" | "P" | "Cl" | "Ar" | "Ca" | "Sc" | "Ti" | "V" | "Cr" | "Mn" | "Fe" | "Co" | "Ni" | "Cu" | "Zn" | "Ga" | "Ge" | "As" | "Se" | "Br" | "Kr" | "Rb" | "Sr" | "Y" | "Zr" | "Nb" | "Mo" | "Tc" | "Ru" | "Rh" | "Pd" | "Ag" | "Cd" | "In" | "Sn" | "Sb" | "Te" | "I" | "Xe" | "Cs" | "Ba" | "La" | "Ce" | "Pr" | "Nd" | "Pm" | "Sm" | "Eu" | "Gd" | "Tb" | "Dy" | "Ho" | "Er" | "Tm" | "Yb" | "Lu" | "Hf" | "Ta" | "W" | "Re" | "Os" | "Ir" | "Pt" | "Au" | "Hg" | "Tl" | "Pb" | "Bi" | "Po" | "At" | "Rn" | "Fr" | "Ra" | "Ac" | "Th" | "Pa" | "U" | "Np" | "Pu" | "Am" | "Cm" | "Bk" | "Cf" | "Es" | "Fm" | "Md" | "No" | "Lr" | "Rf" | "Db" | "Sg" | "Bh" | "Hs" | "Mt" | "Ds" | "Rg" | "Cn" | "Nh" | "Fl" | "Mc" | "Lv" | "Ts" | "Og", number>>;
 export declare function format_chemical_formula(structure: AnyStructure, sort_fn: (symbols: ElementSymbol[]) => ElementSymbol[]): string;
 export declare function format_formula_by_electronegativity(structure: AnyStructure): string;
@@ -94,8 +109,8 @@ export interface StructureHandlerData {
     camera_has_moved?: boolean;
     color_scheme?: string;
     performance_mode?: `quality` | `speed`;
-    scene_props?: ComponentProps<typeof StructureScene>;
-    lattice_props?: ComponentProps<typeof Lattice>;
+    scene_props?: ComponentProps<typeof StructureSceneComponent>;
+    lattice_props?: ComponentProps<typeof LatticeComponent>;
 }
 export interface BondInstance {
     matrix: Float32Array;

package/dist/structure/index.js

@@ -1,6 +1,8 @@
 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';
@@ -17,6 +19,7 @@ export { default as StructureInfoPane } from './StructureInfoPane.svelte';
 export { default as StructureScene } from './StructureScene.svelte';
 export * from './supercell';
 export const LATTICE_PARAM_KEYS = [`a`, `b`, `c`, `alpha`, `beta`, `gamma`];
+export { compose_perceived_bonds, perceive_bond_orders, } from './bond-order-perception';
 export function get_element_counts(structure) {
     const elements = {};
     for (const site of structure.sites) {

package/dist/structure/label-placement.d.ts

@@ -0,0 +1,14 @@
+import type { Vec3 } from '../math';
+import type { Camera, Object3D } from 'three';
+export declare const LABEL_OFFSET_EPS = 1e-9;
+type LabelOffsetSource = Vec3 | (() => Vec3);
+export declare const choose_site_label_offset: (bond_directions: Vec3[], base_offset: Vec3) => Vec3;
+export declare const label_screen_position: (atom_position: Vec3, label_offset: Vec3, visual_radius: number, label_screen_margin: number, label_camera: Camera, size: {
+    width: number;
+    height: number;
+}) => [number, number];
+export declare const make_label_position_calculator: (_atom_position: Vec3, label_offset: LabelOffsetSource, visual_radius: number, label_screen_margin: number) => (object: Object3D, label_camera: Camera, size: {
+    width: number;
+    height: number;
+}) => [number, number];
+export {};

package/dist/structure/label-placement.js

@@ -0,0 +1,72 @@
+import * as math from '../math';
+import { Vector3 } from 'three';
+export const LABEL_OFFSET_EPS = 1e-9;
+const LABEL_OFFSET_DIRECTIONS = [
+    [0, -1, 0],
+    [1, 0, 0],
+    [-1, 0, 0],
+    [1, 1, 0],
+    [-1, 1, 0],
+    [1, -1, 0],
+    [-1, -1, 0],
+    [0, 0, 1],
+    [0, 0, -1],
+];
+const label_direction_score = (direction, bond_directions, preferred_direction) => {
+    let max_bond_alignment = 0;
+    for (const bond_direction of bond_directions) {
+        max_bond_alignment = Math.max(max_bond_alignment, Math.max(0, math.dot(direction, bond_direction)));
+    }
+    const preferred_bonus = Math.max(0, math.dot(direction, preferred_direction)) * 0.05;
+    const screen_plane_bonus = Math.abs(direction[2]) < LABEL_OFFSET_EPS ? 0.02 : 0;
+    return -max_bond_alignment + preferred_bonus + screen_plane_bonus;
+};
+export const choose_site_label_offset = (bond_directions, base_offset) => {
+    const offset_length = Math.hypot(...base_offset);
+    if (offset_length < LABEL_OFFSET_EPS || bond_directions.length === 0) {
+        return base_offset;
+    }
+    const preferred_direction = math.normalize_vec3(base_offset, [0, 1, 0]);
+    const repulsion_direction = math.normalize_vec3(bond_directions.reduce((offset_sum, bond_direction) => math.subtract(offset_sum, bond_direction), [0, 0, 0]), preferred_direction);
+    let best_direction = preferred_direction;
+    let best_score = -Infinity;
+    for (const candidate_direction of [
+        preferred_direction,
+        repulsion_direction,
+        ...LABEL_OFFSET_DIRECTIONS,
+    ]) {
+        const direction = math.normalize_vec3(candidate_direction, preferred_direction);
+        const score = label_direction_score(direction, bond_directions, preferred_direction);
+        if (score <= best_score + LABEL_OFFSET_EPS)
+            continue;
+        best_score = score;
+        best_direction = direction;
+    }
+    return math.scale(best_direction, offset_length);
+};
+const project_to_screen = (position, label_camera, size) => {
+    const projected = new Vector3(...position).project(label_camera);
+    return [
+        (projected.x * size.width) / 2 + size.width / 2,
+        (-projected.y * size.height) / 2 + size.height / 2,
+    ];
+};
+export const label_screen_position = (atom_position, label_offset, visual_radius, label_screen_margin, label_camera, size) => {
+    const atom_screen = project_to_screen(atom_position, label_camera, size);
+    const offset_screen = project_to_screen(math.add(atom_position, label_offset), label_camera, size);
+    const offset_x = offset_screen[0] - atom_screen[0];
+    const offset_y = offset_screen[1] - atom_screen[1];
+    const offset_length = Math.hypot(offset_x, offset_y);
+    const direction_x = offset_length > LABEL_OFFSET_EPS ? offset_x / offset_length : 0;
+    const direction_y = offset_length > LABEL_OFFSET_EPS ? offset_y / offset_length : label_offset[1] >= 0 ? -1 : 1;
+    const radius_direction = math.normalize_vec3(label_offset, [0, 1, 0]);
+    const radius_edge = math.add(atom_position, math.scale(radius_direction, visual_radius));
+    const radius_screen = project_to_screen(radius_edge, label_camera, size);
+    const atom_screen_radius = Math.hypot(radius_screen[0] - atom_screen[0], radius_screen[1] - atom_screen[1]);
+    const screen_gap = atom_screen_radius + label_screen_margin;
+    return [atom_screen[0] + direction_x * screen_gap, atom_screen[1] + direction_y * screen_gap];
+};
+export const make_label_position_calculator = (_atom_position, label_offset, visual_radius, label_screen_margin) => (object, label_camera, size) => {
+    const world_position = object.getWorldPosition(new Vector3());
+    return label_screen_position([world_position.x, world_position.y, world_position.z], typeof label_offset === `function` ? label_offset() : label_offset, visual_radius, label_screen_margin, label_camera, size);
+};

package/dist/structure/parse.d.ts

@@ -1,9 +1,10 @@
 import type { OptimadeStructure } from '../api/optimade';
 import * as math from '../math';
-import type { AnyStructure, Crystal, Site } from './';
+import type { AnyStructure, Crystal, Site, StructureProperties } from './';
 import type { Pbc } from './pbc';
 export interface ParsedStructure {
     sites: Site[];
+    properties?: StructureProperties;
     lattice?: {
         matrix: math.Matrix3x3;
         a: number;

package/dist/structure/parse.js

@@ -250,16 +250,18 @@ export function parse_xyz(content) {
         // Split into frames by reading the atom count and slicing lines
         const all_lines = normalized_content.split(/\r?\n/);
         const frames = [];
-        let line_idx = 0;
-        while (line_idx < all_lines.length) {
-            const numAtoms = parseInt(all_lines[line_idx].trim(), 10);
-            if (!isNaN(numAtoms) && numAtoms > 0 && line_idx + numAtoms + 1 < all_lines.length) {
-                const frameLines = all_lines.slice(line_idx, line_idx + numAtoms + 2);
+        let frame_line_idx = 0;
+        while (frame_line_idx < all_lines.length) {
+            const numAtoms = parseInt(all_lines[frame_line_idx].trim(), 10);
+            if (!isNaN(numAtoms) &&
+                numAtoms > 0 &&
+                frame_line_idx + numAtoms + 1 < all_lines.length) {
+                const frameLines = all_lines.slice(frame_line_idx, frame_line_idx + numAtoms + 2);
                 frames.push(frameLines.join(`\n`));
-                line_idx += numAtoms + 2;
+                frame_line_idx += numAtoms + 2;
             }
             else
-                line_idx++;
+                frame_line_idx++;
         }
         // If no frames found, try simple parsing
         if (frames.length === 0)
@@ -738,8 +740,8 @@ export function parse_cif(content, wrap_fractional_coords = true, strict = true)
             return map;
         })();
         const observed_counts = {};
-        for (const a of atoms) {
-            observed_counts[a.element] = (observed_counts[a.element] || 0) + 1;
+        for (const atom of atoms) {
+            observed_counts[atom.element] = (observed_counts[atom.element] || 0) + 1;
         }
         const has_expected_counts = Object.keys(atom_type_counts).length > 0;
         const already_enumerated = has_expected_counts &&
@@ -1080,46 +1082,33 @@ 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,
+        ...(structure.properties && {
+            properties: clone_structure_properties(structure.properties),
+        }),
+        ...(structure.lattice && {
+            lattice: { ...structure.lattice, pbc: [true, true, true] },
+        }),
+    });
     // Try JSON first, but handle nested structures properly
     try {
         const parsed = JSON.parse(content);
         // Check if it's already a valid structure using proper type guard
         if (is_parsed_structure(parsed)) {
-            // Ensure PBC is set for structures with lattice
-            if (parsed.lattice && !parsed.lattice.pbc) {
-                parsed.lattice.pbc = [true, true, true];
-            }
             // Normalize coordinates (wrap fractional to [0,1) and recompute Cartesian)
-            return normalize_fractional_coords(parsed);
+            return finalize_structure(normalize_fractional_coords(parsed));
         }
         // If not, use parse_structure_file to find nested structures
         const structure = parse_structure_file(content, filename);
-        if (structure) {
-            return {
-                sites: structure.sites,
-                charge: 0,
-                ...(structure.lattice && {
-                    lattice: { ...structure.lattice, pbc: [true, true, true] },
-                }),
-            };
-        }
-        else
-            return null;
+        return structure ? finalize_structure(structure) : null;
     }
     catch {
         // Try structure file formats
         const parsed = parse_structure_file(content, filename);
-        if (parsed) {
-            return {
-                sites: parsed.sites,
-                charge: 0,
-                ...(parsed.lattice && {
-                    lattice: { ...parsed.lattice, pbc: [true, true, true] },
-                }),
-            };
-        }
-        else
-            return null;
+        return parsed ? finalize_structure(parsed) : null;
     }
 }
 // Parse OPTIMADE JSON format

package/dist/structure/supercell.js

@@ -1,6 +1,32 @@
 import * as math from '../math';
 import { scale_lattice_matrix } from '../math';
 import { wrap_frac_coord } from './pbc';
+import { normalize_structure_bond } from './bonding';
+const mod = (value, divisor) => ((value % divisor) + divisor) % divisor;
+const replicate_bonds_for_supercell = (bonds, n_sites, scaling_factors) => {
+    const [scale_x, scale_y, scale_z] = scaling_factors;
+    const replicated = [];
+    const site_offset = ([cell_x, cell_y, cell_z]) => (cell_z * scale_x * scale_y + cell_y * scale_x + cell_x) * n_sites;
+    for (const [source_cell_idx, source_cell] of generate_lattice_points(scaling_factors).entries()) {
+        const source_offset = source_cell_idx * n_sites;
+        for (const { site_idx_1, site_idx_2, order, cell_shift = [0, 0, 0] } of bonds) {
+            const target_raw = [
+                source_cell[0] + cell_shift[0],
+                source_cell[1] + cell_shift[1],
+                source_cell[2] + cell_shift[2],
+            ];
+            const target_cell = [
+                mod(target_raw[0], scale_x),
+                mod(target_raw[1], scale_y),
+                mod(target_raw[2], scale_z),
+            ];
+            const supercell_shift = target_raw.map((val, idx) => Math.floor(val / scaling_factors[idx]));
+            const target_offset = site_offset(target_cell);
+            replicated.push(normalize_structure_bond(site_idx_1 + source_offset, site_idx_2 + target_offset, order, supercell_shift));
+        }
+    }
+    return replicated;
+};
 // 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) {
@@ -40,7 +66,7 @@ export function parse_supercell_scaling(scaling) {
 export function generate_lattice_points(scaling_factors) {
     const [scale_x, scale_y, scale_z] = scaling_factors;
     const count = scale_x * scale_y * scale_z;
-    const points = new Array(count);
+    const points = Array(count);
     let write_idx = 0;
     // Generate in x, y, z order to match expected test results
     for (let kk = 0; kk < scale_z; kk++) {
@@ -79,7 +105,7 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
     };
     // Pre-allocate sites array
     const n_sites = structure.sites.length;
-    const new_sites = new Array(n_sites * total_cells);
+    const new_sites = Array(n_sites * total_cells);
     // Destructure lattice vectors for fast inline arithmetic (avoid function calls in hot loop)
     const [[ax, ay, az], [bx, by, bz], [cx, cy, cz]] = orig_matrix;
     const [sx, sy, sz] = supercell_scaling;
@@ -116,10 +142,17 @@ export function make_supercell(structure, scaling, to_unit_cell = true) {
             }
         }
     }
+    const properties = structure.properties?.bonds === undefined
+        ? structure.properties
+        : {
+            ...structure.properties,
+            bonds: replicate_bonds_for_supercell(structure.properties.bonds, n_sites, supercell_scaling),
+        };
     return {
         ...structure,
         lattice: new_lattice,
         sites: new_sites,
+        properties,
         charge: structure.charge ? structure.charge * total_cells : structure.charge,
         supercell_scaling,
     };

package/dist/symmetry/SymmetryStats.svelte

@@ -1,7 +1,7 @@
 <script lang="ts">
   import type { MoyoDataset } from '@spglib/moyo-wasm'
   import type { Snippet } from 'svelte'
-  import { tooltip } from 'svelte-multiselect'
+  import { tooltip } from 'svelte-multiselect/attachments'
   import type { HTMLAttributes } from 'svelte/elements'
   import { SETTINGS_CONFIG } from '../settings'
   import type { SymmetrySettings } from './index'