matterviz 0.1.0

package/dist/trajectory/Trajectory.svelte.d.ts

@@ -0,0 +1,49 @@
+import { Spinner, Structure } from '..';
+import { ScatterPlot } from '../plot';
+import type { ComponentProps, Snippet } from 'svelte';
+import type { Trajectory, TrajectoryDataExtractor } from './index';
+interface Props {
+    trajectory?: Trajectory | undefined;
+    trajectory_url?: string;
+    current_step_idx?: number;
+    data_extractor?: TrajectoryDataExtractor;
+    allow_file_drop?: boolean;
+    on_file_drop?: (content: string, filename: string) => Promise<void> | void;
+    layout?: `horizontal` | `vertical`;
+    structure_props?: ComponentProps<typeof Structure>;
+    plot_props?: ComponentProps<typeof ScatterPlot>;
+    spinner_props?: ComponentProps<typeof Spinner>;
+    trajectory_controls?: Snippet<[
+        {
+            trajectory: Trajectory;
+            current_step_idx: number;
+            total_frames: number;
+            on_step_change: (idx: number) => void;
+        }
+    ]>;
+    error_snippet?: Snippet<[{
+        error_message: string;
+        on_dismiss: () => void;
+    }]>;
+    show_controls?: boolean;
+    show_fullscreen_button?: boolean;
+    display_mode?: `both` | `structure` | `plot`;
+    step_labels?: number | number[] | undefined;
+    property_labels?: Record<string, string>;
+    units?: {
+        energy?: string;
+        energy_per_atom?: string;
+        force_max?: string;
+        force_norm?: string;
+        stress_max?: string;
+        volume?: string;
+        density?: string;
+        temperature?: string;
+        pressure?: string;
+        length?: string;
+        [key: string]: string | undefined;
+    };
+}
+declare const Trajectory: import("svelte").Component<Props, {}, "trajectory" | "current_step_idx" | "display_mode">;
+type Trajectory = ReturnType<typeof Trajectory>;
+export default Trajectory;

package/dist/trajectory/TrajectoryError.svelte

@@ -0,0 +1,120 @@
+<script lang="ts">let { error_message, on_dismiss, error_snippet } = $props();
+export {};
+</script>
+
+<div class="error-message">
+  {#if error_snippet}
+    {@render error_snippet({ error_message, on_dismiss })}
+  {:else if error_message.includes(`<div class="unsupported-format">`)}
+    <!-- Render HTML content for unsupported format messages -->
+    {@html error_message}
+    <button onclick={on_dismiss}>Dismiss</button>
+  {:else}
+    <h3>Error</h3>
+    <p>{error_message}</p>
+    <button onclick={on_dismiss}>Dismiss</button>
+  {/if}
+</div>
+
+<style>
+  .error-message {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    padding: 2rem;
+    text-align: center;
+    background: var(--trajectory-error-bg, #fff);
+    color: var(--trajectory-error-color, #d73a49);
+    border-radius: 8px;
+    border: 1px solid var(--trajectory-error-border, #f97583);
+    box-sizing: border-box;
+  }
+  .error-message button {
+    margin-top: 1rem;
+    background: var(--trajectory-error-button-bg, #d73a49);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 0.5rem 1rem;
+    cursor: pointer;
+    font-size: 0.9rem;
+    transition: background-color 0.2s;
+  }
+  .error-message button:hover {
+    background: var(--trajectory-error-button-hover-bg, #cb2431);
+  }
+  /* Styles for unsupported format messages */
+  .error-message :global(.unsupported-format) {
+    text-align: left;
+    max-width: 90%;
+    max-height: 70vh;
+    margin: 0 auto;
+    overflow-y: auto;
+    overflow-x: hidden;
+  }
+  .error-message :global(.unsupported-format h4) {
+    color: var(--trajectory-error-color, #d73a49);
+    margin: 0 0 1rem 0;
+    font-size: 1.1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+  }
+  .error-message :global(.unsupported-format h5) {
+    color: var(--trajectory-text-color, #24292e);
+    margin: 0.75rem 0 0.25rem 0;
+    font-size: 0.9rem;
+    font-weight: 600;
+  }
+  .error-message :global(.unsupported-format p) {
+    color: var(--trajectory-text-color, #24292e);
+    margin: 0.25rem 0;
+    text-align: left;
+    font-size: 0.85rem;
+  }
+  .error-message :global(.unsupported-format ul) {
+    text-align: left;
+    margin: 0.5rem 0;
+    padding-left: 1.5rem;
+  }
+  .error-message :global(.unsupported-format li) {
+    color: var(--trajectory-text-color, #24292e);
+    margin: 0.25rem 0;
+  }
+  .error-message :global(.unsupported-format .code-options) {
+    margin: 1rem 0 0 0;
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+    gap: 1.5rem;
+  }
+  .error-message :global(.unsupported-format .code-options > div) {
+    margin: 0;
+  }
+  .error-message :global(.unsupported-format .code-options strong) {
+    color: var(--trajectory-code-title-color, #0366d6);
+    display: block;
+    margin-bottom: 0.25rem;
+    font-size: 0.85rem;
+    font-weight: 600;
+  }
+  .error-message :global(.unsupported-format pre) {
+    background: var(--trajectory-pre-bg, #f6f8fa);
+    padding: 0.5rem;
+    margin: 0;
+    overflow-x: auto;
+    font-family: 'SFMono-Regular', 'Consolas', 'Liberation Mono', 'Menlo', monospace;
+    font-size: 0.75rem;
+    line-height: 1.2;
+    max-height: 150px;
+    overflow-y: auto;
+  }
+  .error-message :global(.unsupported-format p code) {
+    background: var(--trajectory-inline-code-bg, rgba(175, 184, 193, 0.2));
+    padding: 0.2em 0.4em;
+    border-radius: 3px;
+    font-family: 'SFMono-Regular', 'Consolas', 'Liberation Mono', 'Menlo', monospace;
+    font-size: 0.85em;
+  }
+</style>

package/dist/trajectory/TrajectoryError.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { Snippet } from 'svelte';
+interface Props {
+    error_message: string;
+    on_dismiss: () => void;
+    error_snippet?: Snippet<[{
+        error_message: string;
+        on_dismiss: () => void;
+    }]>;
+}
+declare const TrajectoryError: import("svelte").Component<Props, {}, "">;
+type TrajectoryError = ReturnType<typeof TrajectoryError>;
+export default TrajectoryError;

package/dist/trajectory/extract.d.ts

@@ -0,0 +1,5 @@
+import type { TrajectoryDataExtractor } from './index';
+export declare const energy_data_extractor: TrajectoryDataExtractor;
+export declare const force_stress_data_extractor: TrajectoryDataExtractor;
+export declare const structural_data_extractor: TrajectoryDataExtractor;
+export declare const full_data_extractor: TrajectoryDataExtractor;

package/dist/trajectory/extract.js

@@ -0,0 +1,157 @@
+// Common data extractor that extracts energy and structural properties
+export const energy_data_extractor = (frame, _trajectory) => {
+    const data = {
+        Step: frame.step,
+    };
+    if (frame.metadata) {
+        // Extract energy-related properties
+        const energy_fields = [
+            `energy`,
+            `energy_per_atom`,
+            `potential_energy`,
+            `kinetic_energy`,
+            `total_energy`,
+        ];
+        for (const field of energy_fields) {
+            if (field in frame.metadata &&
+                typeof frame.metadata[field] === `number`) {
+                data[field] = frame.metadata[field];
+            }
+        }
+    }
+    return data;
+};
+// Data extractor for forces and stresses
+export const force_stress_data_extractor = (frame, _trajectory) => {
+    const data = {
+        Step: frame.step,
+    };
+    if (frame.metadata) {
+        // Calculate force properties from forces array if available (preferred)
+        if (frame.metadata.forces && Array.isArray(frame.metadata.forces)) {
+            const forces = frame.metadata.forces;
+            if (forces.length > 0) {
+                const force_magnitudes = forces.map((force) => Math.sqrt(force[0] ** 2 + force[1] ** 2 + force[2] ** 2));
+                data.force_max = Math.max(...force_magnitudes);
+                data.force_norm = Math.sqrt(force_magnitudes.reduce((sum, f) => sum + f ** 2, 0) /
+                    force_magnitudes.length);
+            }
+        }
+        else {
+            // Fallback to metadata values if forces array not available
+            if (frame.metadata.force_max &&
+                typeof frame.metadata.force_max === `number`) {
+                data.force_max = frame.metadata.force_max;
+            }
+            // Prefer force_norm if available, fall back to force_rms
+            if (frame.metadata.force_norm &&
+                typeof frame.metadata.force_norm === `number`) {
+                data.force_norm = frame.metadata.force_norm;
+            }
+            else if (frame.metadata.force_rms &&
+                typeof frame.metadata.force_rms === `number`) {
+                data.force_norm = frame.metadata.force_rms; // Use force_rms as fallback
+            }
+        }
+        // Extract other stress and pressure properties (no duplicates expected)
+        const other_stress_fields = [
+            `stress_max`,
+            `stress_frobenius`,
+            `stress_trace`,
+            `pressure`,
+        ];
+        for (const field of other_stress_fields) {
+            if (field in frame.metadata &&
+                typeof frame.metadata[field] === `number`) {
+                data[field] = frame.metadata[field];
+            }
+        }
+    }
+    return data;
+};
+// Data extractor for structural properties
+export const structural_data_extractor = (frame, _trajectory) => {
+    const data = {
+        Step: frame.step,
+    };
+    // Extract lattice properties (preferred source for volume)
+    if (`lattice` in frame.structure) {
+        const lattice = frame.structure.lattice;
+        data.volume = lattice.volume; // Use consistent lowercase naming
+        data.a = lattice.a;
+        data.b = lattice.b;
+        data.c = lattice.c;
+        data.alpha = lattice.alpha;
+        data.beta = lattice.beta;
+        data.gamma = lattice.gamma;
+    }
+    if (frame.metadata) {
+        // Extract other structural properties, avoiding volume duplicate
+        const structural_fields = [`density`, `temperature`];
+        for (const field of structural_fields) {
+            if (field in frame.metadata &&
+                typeof frame.metadata[field] === `number`) {
+                data[field] = frame.metadata[field];
+            }
+        }
+        // Only use metadata volume if lattice volume is not available
+        if (!data.volume &&
+            frame.metadata.volume &&
+            typeof frame.metadata.volume === `number`) {
+            data.volume = frame.metadata.volume;
+        }
+        // Note: pressure is handled by force_stress_data_extractor to avoid duplication
+    }
+    return data;
+};
+// Helper function to check if a property varies across trajectory frames
+function property_varies(trajectory, property_key, tolerance = 1e-10) {
+    if (trajectory.frames.length <= 1)
+        return false;
+    const values = [];
+    for (const frame of trajectory.frames) {
+        // Check both direct structure properties and metadata
+        let value;
+        if (`lattice` in frame.structure) {
+            const lattice = frame.structure.lattice;
+            if (property_key in lattice &&
+                typeof lattice[property_key] === `number`) {
+                value = lattice[property_key];
+            }
+        }
+        if (value === undefined &&
+            frame.metadata &&
+            property_key in frame.metadata) {
+            const metadata_value = frame.metadata[property_key];
+            if (typeof metadata_value === `number`) {
+                value = metadata_value;
+            }
+        }
+        if (value !== undefined) {
+            values.push(value);
+        }
+    }
+    if (values.length <= 1)
+        return false;
+    const first_value = values[0];
+    return values.some((value) => Math.abs(value - first_value) > tolerance);
+}
+// Combined data extractor that extracts all common properties
+export const full_data_extractor = (frame, trajectory) => {
+    const base_data = {
+        ...energy_data_extractor(frame, trajectory),
+        ...force_stress_data_extractor(frame, trajectory),
+        ...structural_data_extractor(frame, trajectory),
+    };
+    // Check which lattice parameters vary
+    const lattice_params = [`a`, `b`, `c`, `alpha`, `beta`, `gamma`];
+    const result = { ...base_data };
+    // Add metadata to specify which properties don't vary
+    for (const param of lattice_params) {
+        if (!property_varies(trajectory, param)) {
+            // Mark individual lattice parameters as constant
+            result[`_constant_${param}`] = 1;
+        }
+    }
+    return result;
+};

package/dist/trajectory/index.d.ts

@@ -0,0 +1,16 @@
+import type { AnyStructure } from '..';
+export { default as Sidebar } from './Sidebar.svelte';
+export { default as TrajectoryViewer } from './Trajectory.svelte';
+export { default as TrajectoryError } from './TrajectoryError.svelte';
+export type TrajectoryFrame = {
+    structure: AnyStructure;
+    step: number;
+    metadata?: Record<string, unknown>;
+};
+export type Trajectory = {
+    frames: TrajectoryFrame[];
+    metadata?: Record<string, unknown>;
+};
+export type TrajectoryDataExtractor = (frame: TrajectoryFrame, trajectory: Trajectory) => Record<string, number>;
+export declare function validate_trajectory(trajectory: Trajectory): string[];
+export declare function get_trajectory_stats(trajectory: Trajectory): Record<string, unknown>;

package/dist/trajectory/index.js

@@ -0,0 +1,49 @@
+export { default as Sidebar } from './Sidebar.svelte';
+export { default as TrajectoryViewer } from './Trajectory.svelte';
+export { default as TrajectoryError } from './TrajectoryError.svelte';
+// Validate trajectory data
+export function validate_trajectory(trajectory) {
+    const errors = [];
+    if (!trajectory.frames || trajectory.frames.length === 0) {
+        errors.push(`Trajectory must have at least one frame`);
+    }
+    for (let idx = 0; idx < trajectory.frames.length; idx++) {
+        const frame = trajectory.frames[idx];
+        if (!frame.structure) {
+            errors.push(`Frame ${idx} missing structure`);
+        }
+        else if (!frame.structure.sites || frame.structure.sites.length === 0) {
+            errors.push(`Frame ${idx} structure has no sites`);
+        }
+        if (typeof frame.step !== `number`) {
+            errors.push(`Frame ${idx} missing or invalid step number`);
+        }
+    }
+    return errors;
+}
+// Get trajectory statistics
+export function get_trajectory_stats(trajectory) {
+    const stats = {
+        frame_count: trajectory.frames.length,
+        steps: trajectory.frames.map((f) => f.step),
+    };
+    if (trajectory.frames.length > 0) {
+        const first_frame = trajectory.frames[0];
+        const last_frame = trajectory.frames[trajectory.frames.length - 1];
+        stats.step_range = [first_frame.step, last_frame.step];
+        // Check if all frames have the same number of atoms
+        const atom_counts = trajectory.frames.map((f) => f.structure.sites.length);
+        const constant_atoms = atom_counts.every((count) => count === atom_counts[0]);
+        stats.constant_atom_count = constant_atoms;
+        if (constant_atoms) {
+            stats.total_atoms = first_frame.structure.sites.length;
+        }
+        else {
+            stats.atom_count_range = [
+                Math.min(...atom_counts),
+                Math.max(...atom_counts),
+            ];
+        }
+    }
+    return stats;
+}

package/dist/trajectory/parse.d.ts

@@ -0,0 +1,13 @@
+import type { Trajectory } from './index';
+export declare function array_buffer_to_data_url(buffer: ArrayBuffer): string;
+export declare function data_url_to_array_buffer(data_url: string): ArrayBuffer;
+export declare function load_trajectory_from_url(url: string): Promise<Trajectory>;
+export declare function parse_torch_sim_hdf5(buffer: ArrayBuffer, filename?: string): Promise<Trajectory>;
+export declare function is_torch_sim_hdf5(content: unknown, filename?: string): boolean;
+export declare function parse_vasp_xdatcar(content: string): Trajectory;
+export declare function is_vasp_xdatcar(content: string, filename?: string): boolean;
+export declare function parse_xyz_trajectory(content: string): Trajectory;
+export declare function is_xyz_trajectory(content: string, filename?: string): boolean;
+export declare function parse_pymatgen_trajectory(obj_data: Record<string, unknown>, filename?: string): Trajectory;
+export declare function parse_trajectory_data(data: unknown, filename?: string): Promise<Trajectory>;
+export declare function get_unsupported_format_message(filename: string, content: string): string | null;