matterviz 0.1.12 → 0.1.13

package/dist/phase-diagram/PhaseDiagramStats.svelte.d.ts

@@ -1,10 +1,10 @@
 import type { HTMLAttributes } from 'svelte/elements';
 import type { PhaseStats, PlotEntry3D } from './types';
-interface Props extends HTMLAttributes<HTMLDivElement> {
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     phase_stats: PhaseStats | null;
     stable_entries: PlotEntry3D[];
     unstable_entries: PlotEntry3D[];
-}
-declare const PhaseDiagramStats: import("svelte").Component<Props, {}, "">;
+};
+declare const PhaseDiagramStats: import("svelte").Component<$$ComponentProps, {}, "">;
 type PhaseDiagramStats = ReturnType<typeof PhaseDiagramStats>;
 export default PhaseDiagramStats;

package/dist/phase-diagram/StructurePopup.svelte.d.ts

@@ -1,6 +1,6 @@
 import type { AnyStructure } from '..';
 import type { HTMLAttributes } from 'svelte/elements';
-interface Props extends HTMLAttributes<HTMLDivElement> {
+type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     structure: AnyStructure;
     place_right?: boolean;
     width?: number;
@@ -11,7 +11,7 @@ interface Props extends HTMLAttributes<HTMLDivElement> {
         e_above_hull?: number;
         e_form?: number;
     };
-}
-declare const StructurePopup: import("svelte").Component<Props, {}, "">;
+};
+declare const StructurePopup: import("svelte").Component<$$ComponentProps, {}, "">;
 type StructurePopup = ReturnType<typeof StructurePopup>;
 export default StructurePopup;

package/dist/phase-diagram/barycentric-coords.js

@@ -20,11 +20,10 @@ export function composition_to_barycentric_3d(composition, elements) {
 }
 // map barycentric coordinates to triangular 2D coordinates
 export function barycentric_to_ternary_xy(barycentric) {
+    const [v0, v1, v2] = TRIANGLE_VERTICES;
     const [a, b, c] = barycentric;
-    const x = TRIANGLE_VERTICES[0][0] * a + TRIANGLE_VERTICES[1][0] * b +
-        TRIANGLE_VERTICES[2][0] * c;
-    const y = TRIANGLE_VERTICES[0][1] * a + TRIANGLE_VERTICES[1][1] * b +
-        TRIANGLE_VERTICES[2][1] * c;
+    const x = v0[0] * a + v1[0] * b + v2[0] * c;
+    const y = v0[1] * a + v1[1] * b + v2[1] * c;
     return [x, y];
 }
 // map barycentric coordinates to ternary 3D coordinates
@@ -33,22 +32,21 @@ export function barycentric_to_ternary_xyz(barycentric, formation_energy) {
     return { x, y, z: formation_energy };
 }
 export function get_triangle_centroid() {
-    const centroid_x = (TRIANGLE_VERTICES[0][0] + TRIANGLE_VERTICES[1][0] + TRIANGLE_VERTICES[2][0]) / 3;
-    const centroid_y = (TRIANGLE_VERTICES[0][1] + TRIANGLE_VERTICES[1][1] + TRIANGLE_VERTICES[2][1]) / 3;
+    const [v0, v1, v2] = TRIANGLE_VERTICES;
+    const centroid_x = (v0[0] + v1[0] + v2[0]) / 3;
+    const centroid_y = (v0[1] + v1[1] + v2[1]) / 3;
     return { x: centroid_x, y: centroid_y, z: 0 };
 }
 export function calculate_face_normal(p1, p2, p3) {
     const edge1 = { x: p2.x - p1.x, y: p2.y - p1.y, z: p2.z - p1.z };
     const edge2 = { x: p3.x - p1.x, y: p3.y - p1.y, z: p3.z - p1.z };
-    const normal = {
-        x: edge1.y * edge2.z - edge1.z * edge2.y,
-        y: edge1.z * edge2.x - edge1.x * edge2.z,
-        z: edge1.x * edge2.y - edge1.y * edge2.x,
-    };
-    const magnitude = Math.sqrt(normal.x ** 2 + normal.y ** 2 + normal.z ** 2);
+    const nx = edge1.y * edge2.z - edge1.z * edge2.y;
+    const ny = edge1.z * edge2.x - edge1.x * edge2.z;
+    const nz = edge1.x * edge2.y - edge1.y * edge2.x;
+    const magnitude = Math.hypot(nx, ny, nz);
     if (magnitude === 0)
         return { x: 0, y: 0, z: 1 };
-    return { x: normal.x / magnitude, y: normal.y / magnitude, z: normal.z / magnitude };
+    return { x: nx / magnitude, y: ny / magnitude, z: nz / magnitude };
 }
 export function calculate_face_centroid(p1, p2, p3) {
     return {
@@ -89,18 +87,9 @@ export function get_ternary_3d_coordinates(entries, elements, el_refs) {
             Number.isFinite(entry.e_form_per_atom)
             ? entry.e_form_per_atom
             : compute_e_form_per_atom(entry, refs) ?? NaN;
-        const { x, y, z } = barycentric_to_ternary_xyz(barycentric, e_form);
+        const xyz = barycentric_to_ternary_xyz(barycentric, e_form);
         const is_element = is_unary_entry(entry);
-        return {
-            ...entry,
-            x,
-            y,
-            z,
-            barycentric,
-            formation_energy: e_form,
-            is_element,
-            visible: true,
-        };
+        return { ...entry, ...xyz, barycentric, e_form, is_element, visible: true };
     });
     return result;
 }

package/dist/phase-diagram/helpers.d.ts

@@ -1,17 +1,6 @@
+import type { EnergyModeInfo } from '..';
 import type { D3InterpolateName } from '../colors';
-import type { PDControlsType, PhaseDiagramConfig, PhaseEntry } from './types';
-export declare const default_controls: PDControlsType;
-export declare const PD_STYLE: Readonly<{
-    structure_line: Readonly<{
-        color: "rgba(128, 128, 128, 0.6)";
-        dash: [number, number];
-        line_width: 2;
-    }>;
-    z_index: Readonly<{
-        tooltip: 6000;
-        copy_feedback: 10000;
-    }>;
-}>;
+import type { PhaseDiagramConfig, PhaseEntry } from './types';
 export declare function get_energy_color_scale(color_mode: `stability` | `energy`, color_scale: D3InterpolateName, plot_entries: {
     e_above_hull?: number;
 }[]): ((value: number) => string) | null;
@@ -20,7 +9,7 @@ export declare function get_point_color_for_entry(entry: {
     e_above_hull?: number;
 }, color_mode: `stability` | `energy`, colors: PhaseDiagramConfig[`colors`] | undefined, energy_scale: ((value: number) => string) | null): string;
 export declare function parse_pd_entries_from_drop(event: DragEvent): Promise<PhaseEntry[] | null>;
-export declare function compute_max_energy_threshold(processed_entries: PhaseEntry[]): number;
+export declare function calc_max_hull_dist_in_data(processed_entries: PhaseEntry[]): number;
 export declare function build_entry_tooltip_text(entry: PhaseEntry): string;
 export declare function find_pd_entry_at_mouse<T extends {
     x: number;
@@ -34,3 +23,12 @@ export declare function find_pd_entry_at_mouse<T extends {
     x: number;
     y: number;
 }): T | null;
+export declare function calculate_modal_side(wrapper: HTMLDivElement | undefined): boolean;
+export declare function setup_fullscreen_effect(fullscreen: boolean, wrapper: HTMLDivElement | undefined, on_fullscreen_change?: (entering_fullscreen: boolean) => void): void;
+export declare function compute_energy_mode_info(entries: PhaseEntry[], // Array of phase entries to analyze
+find_lowest_energy_unary_refs_fn: (entries: PhaseEntry[]) => Record<string, PhaseEntry>, // Function to find unary references
+energy_source_mode: `precomputed` | `on-the-fly`): EnergyModeInfo;
+export declare function get_effective_entries(entries: PhaseEntry[], // Original phase entries
+energy_mode: `precomputed` | `on-the-fly`, // Energy source mode (precomputed or on-the-fly)
+unary_refs: Record<string, PhaseEntry>, // Unary reference entries for energy computation
+compute_e_form_fn: (entry: PhaseEntry, unary_refs: Record<string, PhaseEntry>) => number | null): PhaseEntry[];

package/dist/phase-diagram/helpers.js

@@ -3,28 +3,6 @@ import { format_fractional, format_num } from '../labels';
 import { scaleSequential } from 'd3-scale';
 import * as d3_sc from 'd3-scale-chromatic';
 import { is_unary_entry } from './types';
-// Default legend configuration shared by 3D and 4D diagrams
-export const default_controls = {
-    title: ``,
-    show: true,
-    position: `top-right`,
-    width: 280,
-    show_counts: true,
-    show_color_toggle: true,
-    show_label_controls: true,
-};
-// Shared PD styles (single source of truth shared by 2D, 3D, and 4D)
-export const PD_STYLE = Object.freeze({
-    structure_line: Object.freeze({
-        color: `rgba(128, 128, 128, 0.6)`,
-        dash: [3, 3],
-        line_width: 2,
-    }),
-    z_index: Object.freeze({
-        tooltip: 6000,
-        copy_feedback: 10000,
-    }),
-});
 // Energy color scale factory (shared)
 export function get_energy_color_scale(color_mode, color_scale, plot_entries) {
     if (color_mode !== `energy` || plot_entries.length === 0)
@@ -71,7 +49,7 @@ export async function parse_pd_entries_from_drop(event) {
     }
 }
 // Compute a consistent max energy threshold for controls (shared)
-export function compute_max_energy_threshold(processed_entries) {
+export function calc_max_hull_dist_in_data(processed_entries) {
     if (processed_entries.length === 0)
         return 0.5;
     const hull_distances = processed_entries
@@ -135,3 +113,72 @@ export function find_pd_entry_at_mouse(canvas, event, plot_entries, project_poin
     }
     return null;
 }
+// Calculate which side of the viewport has more space for modal placement
+export function calculate_modal_side(wrapper) {
+    if (!wrapper)
+        return true;
+    const rect = wrapper.getBoundingClientRect();
+    const viewport_width = globalThis.innerWidth;
+    const space_on_right = viewport_width - rect.right;
+    const space_on_left = rect.left;
+    return space_on_right >= space_on_left;
+}
+// Setup fullscreen effect for phase diagrams with optional camera reset callback
+export function setup_fullscreen_effect(fullscreen, wrapper, on_fullscreen_change) {
+    if (typeof window === `undefined`)
+        return;
+    if (fullscreen && !document.fullscreenElement && wrapper?.isConnected) {
+        wrapper.requestFullscreen().catch(console.error);
+        on_fullscreen_change?.(true);
+    }
+    else if (!fullscreen && document.fullscreenElement) {
+        document.exitFullscreen();
+        on_fullscreen_change?.(false);
+    }
+}
+// Compute energy source mode information for phase diagram entries. Returns energy mode information including capability flags and resolved mode.
+// This determines whether we can use precomputed energies or need to compute on-the-fly.
+export function compute_energy_mode_info(entries, // Array of phase entries to analyze
+find_lowest_energy_unary_refs_fn, // Function to find unary references
+energy_source_mode) {
+    const has_precomputed_e_form = entries.length > 0 &&
+        entries.every((e) => typeof e.e_form_per_atom === `number`);
+    const has_precomputed_hull = entries.length > 0 &&
+        entries.every((e) => typeof e.e_above_hull === `number`);
+    const unary_refs = find_lowest_energy_unary_refs_fn(entries);
+    const elements_in_entries = Array.from(new Set(entries.flatMap((e) => Object.keys(e.composition))));
+    const can_compute_e_form = elements_in_entries.every((el) => Boolean(unary_refs[el]));
+    const can_compute_hull = can_compute_e_form;
+    // Resolve mode to avoid inconsistent states:
+    // - If full precomputed available, honor user toggle
+    // - Else if we can compute both, use on-the-fly automatically
+    // - Else fall back to precomputed (best-effort)
+    const energy_mode = has_precomputed_e_form && has_precomputed_hull
+        ? energy_source_mode
+        : can_compute_e_form && can_compute_hull
+            ? `on-the-fly`
+            : `precomputed`;
+    return {
+        has_precomputed_e_form,
+        has_precomputed_hull,
+        can_compute_e_form,
+        can_compute_hull,
+        energy_mode,
+        unary_refs,
+    };
+}
+// Compute effective entries with formation energies based on the energy mode.
+// Returns entries with formation energies populated (either precomputed or on-the-fly)
+export function get_effective_entries(entries, // Original phase entries
+energy_mode, // Energy source mode (precomputed or on-the-fly)
+unary_refs, // Unary reference entries for energy computation
+compute_e_form_fn) {
+    if (energy_mode === `precomputed`)
+        return entries;
+    return entries.map((entry) => {
+        const e_form = compute_e_form_fn(entry, unary_refs);
+        if (e_form === null)
+            return entry;
+        return { ...entry, e_form_per_atom: e_form };
+    });
+}

package/dist/phase-diagram/index.d.ts

@@ -1,3 +1,6 @@
+import type { D3InterpolateName } from '../colors';
+import type { HTMLAttributes } from 'svelte/elements';
+import type { HoverData3D, PDControlsType, PhaseDiagramConfig, PhaseEntry, PhaseStats } from './types';
 export * from './barycentric-coords';
 export { default as PhaseDiagram2D } from './PhaseDiagram2D.svelte';
 export { default as PhaseDiagram3D } from './PhaseDiagram3D.svelte';
@@ -7,3 +10,58 @@ export { default as PhaseDiagramInfoPane } from './PhaseDiagramInfoPane.svelte';
 export { default as PhaseDiagramStats } from './PhaseDiagramStats.svelte';
 export * from './thermodynamics';
 export * from './types';
+export interface BasePhaseDiagramProps<TEntry = PhaseEntry> extends Omit<HTMLAttributes<HTMLDivElement>, `entries`> {
+    entries: PhaseEntry[];
+    controls?: Partial<PDControlsType>;
+    config?: Partial<PhaseDiagramConfig>;
+    on_point_click?: (entry: TEntry) => void;
+    on_point_hover?: (data: HoverData3D<TEntry> | null) => void;
+    fullscreen?: boolean;
+    enable_fullscreen?: boolean;
+    enable_info_pane?: boolean;
+    wrapper?: HTMLDivElement;
+    label_threshold?: number;
+    show_stable?: boolean;
+    show_unstable?: boolean;
+    color_mode?: `stability` | `energy`;
+    color_scale?: D3InterpolateName;
+    info_pane_open?: boolean;
+    legend_pane_open?: boolean;
+    max_hull_dist_show_phases?: number;
+    max_hull_dist_show_labels?: number;
+    show_stable_labels?: boolean;
+    show_unstable_labels?: boolean;
+    on_file_drop?: (entries: PhaseEntry[]) => void;
+    enable_structure_preview?: boolean;
+    energy_source_mode?: `precomputed` | `on-the-fly`;
+    phase_stats?: PhaseStats | null;
+}
+export interface Hull3DProps {
+    show_hull_faces?: boolean;
+    hull_face_opacity?: number;
+}
+export interface MergedPDConfig {
+    controls: PDControlsType;
+    config: PhaseDiagramConfig;
+}
+export interface EnergyModeInfo {
+    has_precomputed_e_form: boolean;
+    has_precomputed_hull: boolean;
+    can_compute_e_form: boolean;
+    can_compute_hull: boolean;
+    energy_mode: `precomputed` | `on-the-fly`;
+    unary_refs: Record<string, PhaseEntry>;
+}
+export declare const default_controls: PDControlsType;
+export declare const default_pd_config: PhaseDiagramConfig;
+export declare const PD_STYLE: Readonly<{
+    structure_line: Readonly<{
+        color: "rgba(128, 128, 128, 0.6)";
+        dash: [number, number];
+        line_width: 2;
+    }>;
+    z_index: Readonly<{
+        tooltip: 6000;
+        copy_feedback: 10000;
+    }>;
+}>;

package/dist/phase-diagram/index.js

@@ -7,3 +7,47 @@ export { default as PhaseDiagramInfoPane } from './PhaseDiagramInfoPane.svelte';
 export { default as PhaseDiagramStats } from './PhaseDiagramStats.svelte';
 export * from './thermodynamics';
 export * from './types';
+// Default legend configuration shared by 3D and 4D diagrams
+export const default_controls = {
+    title: ``,
+    show: true,
+    position: `top-right`,
+    width: 280,
+    show_counts: true,
+    show_color_toggle: true,
+    show_label_controls: true,
+};
+// Phase diagram defaults shared by 2D, 3D, and 4D
+export const default_pd_config = {
+    width: 600,
+    height: 600,
+    unstable_threshold: 0.2,
+    show_labels: true,
+    show_hull: true,
+    point_size: 8,
+    line_width: 2,
+    font_size: 12,
+    colors: {
+        stable: `#0072B2`,
+        unstable: `#E69F00`,
+        hull_line: `var(--accent-color, #1976D2)`,
+        background: `transparent`,
+        text: `var(--text-color, #212121)`,
+        edge: `var(--text-color, #212121)`,
+        tooltip_bg: `var(--tooltip-bg, rgba(0, 0, 0, 0.85))`,
+        tooltip_text: `var(--tooltip-text, white)`,
+        annotation: `var(--text-color, #212121)`,
+    },
+};
+// Shared PD styles (single source of truth shared by 2D, 3D, and 4D)
+export const PD_STYLE = Object.freeze({
+    structure_line: Object.freeze({
+        color: `rgba(128, 128, 128, 0.6)`,
+        dash: [3, 3],
+        line_width: 2,
+    }),
+    z_index: Object.freeze({
+        tooltip: 6000,
+        copy_feedback: 10000,
+    }),
+});

package/dist/phase-diagram/thermodynamics.js

@@ -60,7 +60,7 @@ export function find_lowest_energy_unary_refs(entries) {
     for (const entry of entries) {
         if (!is_unary_entry(entry))
             continue;
-        const el = Object.keys(entry.composition).find((k) => entry.composition[k] > 0);
+        const el = Object.keys(entry.composition).find((el) => entry.composition[el] > 0);
         if (!el)
             continue;
         const atoms = Object.values(entry.composition).reduce((sum, amt) => sum + amt, 0);
@@ -87,8 +87,7 @@ export function find_lowest_energy_unary_refs(entries) {
 export function get_phase_diagram_stats(processed_entries, elements, max_arity) {
     if (!processed_entries || processed_entries.length === 0)
         return null;
-    const composition_counts = (max_arity === 4 ? [1, 2, 3, 4] : [1, 2, 3]).map((target) => processed_entries.filter((entry) => Object.keys(entry.composition).filter((el) => entry.composition[el] > 0).length ===
-        target).length);
+    const composition_counts = (max_arity === 4 ? [1, 2, 3, 4] : [1, 2, 3]).map((target) => processed_entries.filter((entry) => Object.keys(entry.composition).filter((el) => entry.composition[el] > 0).length === target).length);
     const [unary, binary, ternary, quaternaryMaybe] = composition_counts;
     const quaternary = max_arity === 4 ? (quaternaryMaybe ?? 0) : 0;
     const stable_count = processed_entries.filter((e) => e.is_stable === true ||

package/dist/phase-diagram/types.d.ts

@@ -1,4 +1,4 @@
-import type { ElementSymbol } from '..';
+import type { ElementSymbol, Sides } from '..';
 import type { Vec3 } from '../math';
 export interface PhaseEntry {
     composition: Record<ElementSymbol, number>;
@@ -41,12 +41,7 @@ export interface PlotEntry3D extends PhaseEntry, Point3D {
 export interface PhaseDiagramConfig {
     width?: number;
     height?: number;
-    margin?: {
-        top: number;
-        right: number;
-        bottom: number;
-        left: number;
-    };
+    margin?: Sides;
     unstable_threshold?: number;
     show_labels?: boolean;
     show_hull?: boolean;
@@ -91,7 +86,7 @@ export interface ConvexHullTriangle {
 }
 export interface TernaryPlotEntry extends PlotEntry3D {
     barycentric: [number, number, number];
-    formation_energy: number;
+    e_form: number;
 }
 export interface HoverData3D<T = PlotEntry3D> {
     entry: T;