matterviz 0.1.12 → 0.1.13

package/dist/phase-diagram/PhaseDiagram3D.svelte

@@ -5,81 +5,33 @@ import { format_fractional, format_num } from '../labels';
 import { ColorBar } from '../plot';
 import { SvelteMap } from 'svelte/reactivity';
 import { get_ternary_3d_coordinates, get_triangle_centroid, get_triangle_edges, get_triangle_vertical_edges, TRIANGLE_VERTICES, } from './barycentric-coords';
-import { build_entry_tooltip_text, compute_max_energy_threshold, default_controls, find_pd_entry_at_mouse, get_energy_color_scale, get_point_color_for_entry, parse_pd_entries_from_drop, PD_STYLE, } from './helpers';
+import * as helpers from './helpers';
+import { default_controls, default_pd_config, PD_STYLE } from './index';
 import PhaseDiagramControls from './PhaseDiagramControls.svelte';
 import PhaseDiagramInfoPane from './PhaseDiagramInfoPane.svelte';
 import StructurePopup from './StructurePopup.svelte';
-import { build_lower_hull_model, compute_e_above_hull_for_points, compute_e_form_per_atom, compute_lower_hull_triangles, find_lowest_energy_unary_refs, get_phase_diagram_stats, process_pd_entries, } from './thermodynamics';
-let { entries, controls = {}, config = {}, on_point_click, on_point_hover, fullscreen = $bindable(false), enable_fullscreen = true, enable_info_pane = true, wrapper = $bindable(undefined), label_threshold = 50, show_stable = $bindable(true), show_unstable = $bindable(true), show_hull_faces = $bindable(true), hull_face_opacity = $bindable(0.3), color_mode = $bindable(`energy`), color_scale = $bindable(`interpolateViridis`), info_pane_open = $bindable(false), legend_pane_open = $bindable(false), energy_threshold = $bindable(0.5), // eV/atom above hull for showing entries
-on_file_drop, enable_structure_preview = true, energy_source_mode = $bindable(`precomputed`), phase_stats = $bindable(null), stable_entries_out = $bindable([]), unstable_entries_out = $bindable([]), ...rest } = $props();
-const merged_controls = $derived({
-    ...default_controls,
-    ...controls,
-});
-const default_config = {
-    margin: { top: 40, right: 40, bottom: 60, left: 60 },
-    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)`,
-    },
-};
+import * as thermo from './thermodynamics';
+let { entries, controls = {}, config = {}, on_point_click, on_point_hover, fullscreen = $bindable(false), enable_fullscreen = true, enable_info_pane = true, wrapper = $bindable(undefined), label_threshold = 50, show_stable = $bindable(true), show_unstable = $bindable(true), show_hull_faces = $bindable(true), hull_face_opacity = $bindable(0.3), color_mode = $bindable(`energy`), color_scale = $bindable(`interpolateViridis`), info_pane_open = $bindable(false), legend_pane_open = $bindable(false), max_hull_dist_show_phases = $bindable(0.5), // eV/atom above hull for showing entries
+on_file_drop, enable_structure_preview = true, energy_source_mode = $bindable(`precomputed`), phase_stats = $bindable(null), stable_entries = $bindable([]), unstable_entries = $bindable([]), ...rest } = $props();
+const merged_controls = $derived({ ...default_controls, ...controls });
 const merged_config = $derived({
-    ...default_config,
+    ...default_pd_config,
     ...config,
-    margin: { ...default_config.margin, ...(config.margin || {}) },
-});
-// Decide which energy source to use per entry
-const has_precomputed_e_form = $derived(entries.length > 0 && entries.every((e) => typeof e.e_form_per_atom === `number`));
-const has_precomputed_hull = $derived(entries.length > 0 && entries.every((e) => typeof e.e_above_hull === `number`));
-// Build unary references once from entries; inexpensive and used for capability checks
-const unary_refs = $derived.by(() => find_lowest_energy_unary_refs(entries));
-const can_compute_e_form = $derived.by(() => {
-    const elements_in_entries = Array.from(new Set(entries.flatMap((e) => Object.keys(e.composition))));
-    return elements_in_entries.every((el) => Boolean(unary_refs[el]));
-});
-const can_compute_hull = $derived(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 = $derived((has_precomputed_e_form && has_precomputed_hull)
-    ? energy_source_mode
-    : ((can_compute_e_form && can_compute_hull) ? `on-the-fly` : `precomputed`));
-const effective_entries = $derived.by(() => {
-    if (energy_mode === `precomputed`)
-        return entries;
-    return entries.map((entry) => {
-        const e_form = compute_e_form_per_atom(entry, unary_refs);
-        if (e_form == null)
-            return entry;
-        return { ...entry, e_form_per_atom: e_form };
-    });
+    colors: { ...default_pd_config.colors, ...(config.colors || {}) },
+    margin: { t: 40, r: 40, b: 60, l: 60, ...(config.margin || {}) },
 });
+let { // Compute energy mode information
+has_precomputed_e_form, has_precomputed_hull, can_compute_e_form, can_compute_hull, energy_mode, unary_refs, } = $derived(helpers.compute_energy_mode_info(entries, thermo.find_lowest_energy_unary_refs, energy_source_mode));
+const effective_entries = $derived(helpers.get_effective_entries(entries, energy_mode, unary_refs, thermo.compute_e_form_per_atom));
 // Process phase diagram data with unified PhaseEntry interface using effective entries
 const processed_entries = $derived(effective_entries);
-const pd_data = $derived(process_pd_entries(processed_entries));
+const pd_data = $derived(thermo.process_pd_entries(processed_entries));
 const elements = $derived.by(() => {
-    const all_elements = pd_data.elements;
-    if (all_elements.length > 3) {
-        console.error(`PhaseDiagram3D: Dataset contains ${all_elements.length} elements, but ternary diagrams require exactly 3. Found: [${all_elements.join(`, `)}]`);
+    if (pd_data.elements.length > 3) {
+        console.error(`PhaseDiagram3D: Dataset contains ${pd_data.elements.length} elements, but ternary diagrams require exactly 3. Found: [${pd_data.elements.join(`, `)}]`);
         return [];
     }
-    return all_elements;
+    return pd_data.elements;
 });
 // 1) Raw 3D coordinates (formation-energy z), independent of hull state
 const coords_entries = $derived.by(() => {
@@ -103,12 +55,12 @@ const plot_entries = $derived.by(() => {
     const enriched = (() => {
         if (energy_mode === `on-the-fly`) {
             const pts = coords_entries.map((e) => ({ x: e.x, y: e.y, z: e.z }));
-            const e_hulls = compute_e_above_hull_for_points(pts, hull_model);
+            const e_hulls = thermo.compute_e_above_hull_for_points(pts, hull_model);
             return coords_entries.map((e, idx) => ({ ...e, e_above_hull: e_hulls[idx] }));
         }
         return coords_entries;
     })();
-    const energy_filtered = enriched.filter((entry) => (entry.e_above_hull ?? 0) <= energy_threshold);
+    const energy_filtered = enriched.filter((entry) => (entry.e_above_hull ?? 0) <= max_hull_dist_show_phases);
     return energy_filtered.map((entry) => {
         const is_stable = entry.is_stable || entry.e_above_hull === 0;
         return {
@@ -117,16 +69,18 @@ const plot_entries = $derived.by(() => {
         };
     });
 });
-const stable_entries = $derived(plot_entries.filter((entry) => entry.is_stable || entry.e_above_hull === 0));
-const unstable_entries = $derived(plot_entries.filter((entry) => typeof entry.e_above_hull === `number` && entry.e_above_hull > 0 &&
-    !entry.is_stable));
+$effect(() => {
+    stable_entries = plot_entries.filter((entry) => entry.is_stable || entry.e_above_hull === 0);
+    unstable_entries = plot_entries.filter((entry) => typeof entry.e_above_hull === `number` && entry.e_above_hull > 0 &&
+        !entry.is_stable);
+});
 const hull_faces = $derived.by(() => {
     if (coords_entries.length === 0) {
         return [];
     }
     const points = coords_entries.map((e) => ({ x: e.x, y: e.y, z: e.z }));
     try {
-        return compute_lower_hull_triangles(points);
+        return thermo.compute_lower_hull_triangles(points);
     }
     catch (error) {
         console.error(`Error computing convex hull:`, error);
@@ -134,7 +88,7 @@ const hull_faces = $derived.by(() => {
     }
 });
 // Cached hull model for e_above_hull queries; recompute only when faces change
-let hull_model = $derived.by(() => build_lower_hull_model(hull_faces));
+let hull_model = $derived.by(() => thermo.build_lower_hull_model(hull_faces));
 // Total counts based on hull-enriched entries
 const total_unstable_count = $derived(plot_entries.filter((entry) => typeof entry.e_above_hull === `number` && entry.e_above_hull > 0 &&
     !entry.is_stable).length);
@@ -203,32 +157,18 @@ $effect(() => {
 $effect(() => {
     // deno-fmt-ignore
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-    [show_stable, show_unstable, show_hull_faces, color_mode, color_scale, energy_threshold, show_stable_labels, show_unstable_labels, label_energy_threshold, camera.elevation, camera.azimuth, camera.zoom, camera.center_x, camera.center_y, plot_entries, hull_face_color, hull_face_opacity];
+    [show_stable, show_unstable, show_hull_faces, color_mode, color_scale, max_hull_dist_show_phases, show_stable_labels, show_unstable_labels, max_hull_dist_show_labels, camera.elevation, camera.azimuth, camera.zoom, camera.center_x, camera.center_y, plot_entries, hull_face_color, hull_face_opacity];
     render_once();
 });
 // Label controls with smart defaults based on entry count
 let show_stable_labels = $state(true);
 let show_unstable_labels = $state(false);
-let label_energy_threshold = $state(0.1); // eV/atom above hull for showing labels
-// Smart label defaults - hide labels if too many entries
-$effect(() => {
-    const total_entries = processed_entries.length;
-    if (total_entries > label_threshold) {
-        show_stable_labels = false;
-        show_unstable_labels = false;
-    }
-    else {
-        // For smaller datasets, show stable labels by default
-        show_stable_labels = true;
-        show_unstable_labels = false;
-    }
-});
+let max_hull_dist_show_labels = $state(0.1); // eV/atom above hull for showing labels
 // Function to extract structure data from a phase diagram entry
 function extract_structure_from_entry(entry) {
     const original_entry = entries.find((orig_entry) => orig_entry.entry_id === entry.entry_id);
     return original_entry?.structure || null;
 }
-const get_tooltip_text = (entry) => build_entry_tooltip_text(entry);
 const reset_camera = () => Object.assign(camera, camera_default);
 function reset_all() {
     reset_camera();
@@ -241,8 +181,8 @@ function reset_all() {
     show_unstable = PD_DEFAULTS.ternary.show_unstable;
     show_stable_labels = PD_DEFAULTS.ternary.show_stable_labels;
     show_unstable_labels = PD_DEFAULTS.ternary.show_unstable_labels;
-    label_energy_threshold = PD_DEFAULTS.ternary.label_energy_threshold;
-    energy_threshold = PD_DEFAULTS.ternary.energy_threshold;
+    max_hull_dist_show_labels = PD_DEFAULTS.ternary.max_hull_dist_show_labels;
+    max_hull_dist_show_phases = PD_DEFAULTS.ternary.max_hull_dist_show_phases;
     show_hull_faces = PD_DEFAULTS.ternary.show_hull_faces;
     hull_face_color = PD_DEFAULTS.ternary.hull_face_color;
     hull_face_opacity = PD_DEFAULTS.ternary.hull_face_opacity;
@@ -262,7 +202,7 @@ const handle_keydown = (event) => {
 };
 async function handle_file_drop(event) {
     drag_over = false;
-    const data = await parse_pd_entries_from_drop(event);
+    const data = await helpers.parse_pd_entries_from_drop(event);
     if (data)
         on_file_drop?.(data);
 }
@@ -272,20 +212,13 @@ async function copy_to_clipboard(text, position) {
     copy_feedback_visible = true;
     setTimeout(() => copy_feedback_visible = false, 1500);
 }
-function get_point_color(entry) {
-    return get_point_color_for_entry(entry, color_mode, merged_config.colors, energy_color_scale);
-}
+const get_point_color = (entry) => helpers.get_point_color_for_entry(entry, color_mode, merged_config.colors, energy_color_scale);
 // Cache energy color scale per frame/setting
-const energy_color_scale = $derived.by(() => get_energy_color_scale(color_mode, color_scale, plot_entries));
-const max_energy_threshold = $derived(compute_max_energy_threshold(processed_entries));
+const energy_color_scale = $derived.by(() => helpers.get_energy_color_scale(color_mode, color_scale, plot_entries));
+const max_hull_dist_in_data = $derived(helpers.calc_max_hull_dist_in_data(processed_entries));
 // Phase diagram statistics - compute internally and expose via bindable prop
 $effect(() => {
-    phase_stats = get_phase_diagram_stats(processed_entries, elements, 3);
-});
-// Sync stable and unstable entries to bindable props
-$effect(() => {
-    stable_entries_out = stable_entries;
-    unstable_entries_out = unstable_entries;
+    phase_stats = thermo.get_phase_diagram_stats(processed_entries, elements, 3);
 });
 // 3D to 2D projection for ternary diagrams
 function project_3d_point(x, y, z) {
@@ -294,7 +227,7 @@ function project_3d_point(x, y, z) {
     // Center coordinates around the volumetric center of the phase diagram
     const triangle_centroid = get_triangle_centroid();
     // Calculate the energy center (middle of formation energy range)
-    const formation_energies = plot_entries.map((e) => e.formation_energy);
+    const formation_energies = plot_entries.map((e) => e.e_form);
     const e_form_min = Math.min(0, ...formation_energies);
     const e_form_max = Math.max(0, ...formation_energies);
     const energy_center = (e_form_min + e_form_max) / 2;
@@ -349,7 +282,7 @@ function draw_triangle_structure() {
     if (!ctx)
         return;
     // Get formation energy range for vertical edges
-    const formation_energies = plot_entries.map((e) => e.formation_energy);
+    const formation_energies = plot_entries.map((e) => e.e_form);
     const e_form_min = Math.min(0, ...formation_energies); // Include 0 for elemental references
     const e_form_max = Math.max(0, ...formation_energies); // Include 0 for elemental references
     // Draw base triangle edges (top triangle at formation energy = 0)
@@ -418,7 +351,7 @@ function draw_convex_hull_faces() {
     if (!ctx || !show_hull_faces || hull_faces.length === 0)
         return;
     // Normalize alpha by formation energy: 0 eV -> 0 alpha, min E_form -> hull_face_opacity
-    const formation_energies = plot_entries.map((e) => e.formation_energy);
+    const formation_energies = plot_entries.map((e) => e.e_form);
     const min_fe = Math.min(0, ...formation_energies);
     const norm_alpha = (z) => {
         const t = Math.max(0, Math.min(1, (0 - z) / Math.max(1e-6, 0 - min_fe)));
@@ -504,7 +437,7 @@ function draw_convex_hull_faces() {
 }
 // Formation energy color bar helpers
 const e_form_range = $derived.by(() => {
-    const energies = plot_entries.map((e) => e.formation_energy);
+    const energies = plot_entries.map((e) => e.e_form);
     const min_fe = energies.length ? Math.min(0, ...energies) : -1;
     return [min_fe, 0];
 });
@@ -604,36 +537,22 @@ function draw_hull_labels() {
         const can_label_stable = is_stable_point && show_stable_labels;
         const can_label_unstable = !is_stable_point && show_unstable_labels &&
             (typeof entry.e_above_hull === `number` &&
-                entry.e_above_hull <= label_energy_threshold);
+                entry.e_above_hull <= max_hull_dist_show_labels);
         if (!(can_label_stable || can_label_unstable))
             continue;
         const projected = project_3d_point(entry.x, entry.y, entry.z);
-        // Generate simplified formula from composition
+        // Generate label from composition
         let formula = entry.reduced_formula || entry.name || ``;
         if (!formula) {
-            // Generate reduced formula from composition
-            const composition_elements = Object.entries(entry.composition)
+            // Format composition as element fractions
+            formula = Object.entries(entry.composition)
                 .filter(([, amt]) => amt > 0)
                 .sort(([el1], [el2]) => elements.indexOf(el1) -
-                elements.indexOf(el2));
-            // Find GCD to reduce the formula
-            const amounts = composition_elements.map(([, amt]) => Math.round(amt * 1000) / 1000);
-            const gcd_val = amounts.reduce((a, b) => {
-                // Simple GCD for fractional numbers (scaled by 1000)
-                const scale = 1000;
-                let a_int = Math.round(a * scale);
-                let b_int = Math.round(b * scale);
-                while (b_int !== 0) {
-                    const temp = b_int;
-                    b_int = a_int % b_int;
-                    a_int = temp;
-                }
-                return a_int / scale;
-            });
-            formula = composition_elements
+                elements.indexOf(el2))
                 .map(([element, amount]) => {
-                const reduced_amount = Math.round((amount / gcd_val) * 100) / 100;
-                return reduced_amount === 1 ? element : `${element}${reduced_amount}`;
+                if (Math.abs(amount - 1) < 1e-6)
+                    return element;
+                return `${element}${format_num(amount, `.2~`)}`;
             })
                 .join(``);
         }
@@ -710,7 +629,7 @@ const handle_hover = (event) => {
         : null;
     on_point_hover?.(hover_data);
 };
-const find_entry_at_mouse = (event) => find_pd_entry_at_mouse(canvas, event, plot_entries, (x, y, z) => {
+const find_entry_at_mouse = (event) => helpers.find_pd_entry_at_mouse(canvas, event, plot_entries, (x, y, z) => {
     const pt = project_3d_point(x, y, z);
     return { x: pt.x, y: pt.y };
 });
@@ -729,7 +648,7 @@ const handle_click = (event) => {
             if (structure) {
                 selected_structure = structure;
                 selected_entry = entry;
-                calculate_modal_side();
+                modal_place_right = helpers.calculate_modal_side(wrapper);
                 modal_open = true;
             }
         }
@@ -737,16 +656,6 @@ const handle_click = (event) => {
     else if (modal_open)
         close_structure_popup();
 };
-// Decide side based on available viewport room; modal is absolutely positioned
-function calculate_modal_side() {
-    if (!wrapper)
-        return;
-    const rect = wrapper.getBoundingClientRect();
-    const viewport_width = globalThis.innerWidth;
-    const space_on_right = viewport_width - rect.right;
-    const space_on_left = rect.left;
-    modal_place_right = space_on_right >= space_on_left;
-}
 function close_structure_popup() {
     modal_open = false;
     selected_structure = null;
@@ -755,7 +664,7 @@ function close_structure_popup() {
 const handle_double_click = (event) => {
     const entry = find_entry_at_mouse(event);
     if (entry) {
-        copy_to_clipboard(get_tooltip_text(entry), {
+        copy_to_clipboard(helpers.build_entry_tooltip_text(entry), {
             x: event.clientX,
             y: event.clientY,
         });
@@ -819,20 +728,14 @@ $effect(() => {
 // Fullscreen handling with camera reset on transitions
 let was_fullscreen = $state(fullscreen);
 $effect(() => {
-    if (typeof window === `undefined`)
-        return;
-    if (fullscreen && !document.fullscreenElement && wrapper?.isConnected) {
-        wrapper.requestFullscreen().catch(console.error);
-    }
-    else if (!fullscreen && document.fullscreenElement) {
-        document.exitFullscreen();
-    }
-    // Reset camera only on fullscreen transitions
-    if (fullscreen !== was_fullscreen) {
-        camera.center_x = 0;
-        camera.center_y = -50;
-        was_fullscreen = fullscreen;
-    }
+    helpers.setup_fullscreen_effect(fullscreen, wrapper, (entering_fullscreen) => {
+        // Reset camera only on fullscreen transitions
+        if (entering_fullscreen !== was_fullscreen) {
+            camera.center_x = 0;
+            camera.center_y = -50;
+            was_fullscreen = entering_fullscreen;
+        }
+    });
 });
 let style = $derived(`--pd-stable-color:${merged_config.colors?.stable || `#0072B2`};
     --pd-unstable-color:${merged_config.colors?.unstable || `#E69F00`};
@@ -882,13 +785,11 @@ let style = $derived(`--pd-stable-color:${merged_config.colors?.stable || `#0072
 
   <!-- Formation Energy Color Bar (bottom-left corner) -->
   {#if color_mode === `energy` && plot_entries.length > 0}
-    {@const formation_energies = plot_entries
+    {@const hull_distances = plot_entries
       .map((e) => e.e_above_hull)
       .filter((v): v is number => typeof v === `number`)}
-    {@const min_energy = formation_energies.length > 0 ? Math.min(...formation_energies) : 0}
-    {@const max_energy = formation_energies.length > 0
-      ? Math.max(...formation_energies, 0.1)
-      : 0.1}
+    {@const min_energy = hull_distances.length > 0 ? Math.min(...hull_distances) : 0}
+    {@const max_energy = hull_distances.length > 0 ? Math.max(...hull_distances, 0.1) : 0.1}
     <ColorBar
       title="Energy above hull (eV/atom)"
       range={[min_energy, max_energy]}
@@ -930,12 +831,10 @@ let style = $derived(`--pd-stable-color:${merged_config.colors?.stable || `#0072
           {phase_stats}
           {stable_entries}
           {unstable_entries}
-          {energy_threshold}
-          {label_energy_threshold}
+          {max_hull_dist_show_phases}
+          {max_hull_dist_show_labels}
           {label_threshold}
-          toggle_props={{
-            class: `info-btn`,
-          }}
+          toggle_props={{ class: `info-btn` }}
         />
       {/if}
 
@@ -959,17 +858,15 @@ let style = $derived(`--pd-stable-color:${merged_config.colors?.stable || `#0072
         bind:show_unstable
         bind:show_stable_labels
         bind:show_unstable_labels
-        bind:energy_threshold
-        bind:label_energy_threshold
-        {max_energy_threshold}
+        bind:max_hull_dist_show_phases
+        bind:max_hull_dist_show_labels
+        {max_hull_dist_in_data}
         {stable_entries}
         {unstable_entries}
         {total_unstable_count}
         {camera}
         {merged_controls}
-        toggle_props={{
-          class: `legend-controls-btn`,
-        }}
+        toggle_props={{ class: `legend-controls-btn` }}
         {show_hull_faces}
         on_hull_faces_change={(value) => show_hull_faces = value}
         {hull_face_color}

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

@@ -1,33 +1,9 @@
-import type { D3InterpolateName } from '../colors';
-import type { HTMLAttributes } from 'svelte/elements';
-import type { HoverData3D, PDControlsType, PhaseDiagramConfig, PhaseEntry, PhaseStats, TernaryPlotEntry } from './types';
-interface Props extends HTMLAttributes<HTMLDivElement> {
-    entries: PhaseEntry[];
-    controls?: Partial<PDControlsType>;
-    config?: Partial<PhaseDiagramConfig>;
-    on_point_click?: (entry: TernaryPlotEntry) => void;
-    on_point_hover?: (data: HoverData3D<TernaryPlotEntry> | null) => void;
-    fullscreen?: boolean;
-    enable_fullscreen?: boolean;
-    enable_info_pane?: boolean;
-    wrapper?: HTMLDivElement;
-    label_threshold?: number;
-    show_stable?: boolean;
-    show_unstable?: boolean;
-    show_hull_faces?: boolean;
-    hull_face_opacity?: number;
-    color_mode?: `stability` | `energy`;
-    color_scale?: D3InterpolateName;
-    info_pane_open?: boolean;
-    legend_pane_open?: boolean;
-    energy_threshold?: number;
-    on_file_drop?: (entries: PhaseEntry[]) => void;
-    enable_structure_preview?: boolean;
-    energy_source_mode?: `precomputed` | `on-the-fly`;
-    phase_stats?: PhaseStats | null;
-    stable_entries_out?: TernaryPlotEntry[];
-    unstable_entries_out?: TernaryPlotEntry[];
-}
-declare const PhaseDiagram3D: import("svelte").Component<Props, {}, "color_mode" | "color_scale" | "show_stable" | "show_unstable" | "energy_threshold" | "fullscreen" | "info_pane_open" | "legend_pane_open" | "show_hull_faces" | "hull_face_opacity" | "wrapper" | "energy_source_mode" | "phase_stats" | "stable_entries_out" | "unstable_entries_out">;
+import type { BasePhaseDiagramProps, Hull3DProps } from './index';
+import type { TernaryPlotEntry } from './types';
+type $$ComponentProps = BasePhaseDiagramProps<TernaryPlotEntry> & Hull3DProps & {
+    stable_entries?: TernaryPlotEntry[];
+    unstable_entries?: TernaryPlotEntry[];
+};
+declare const PhaseDiagram3D: import("svelte").Component<$$ComponentProps, {}, "show_hull_faces" | "hull_face_opacity" | "color_mode" | "color_scale" | "show_stable" | "show_unstable" | "max_hull_dist_show_phases" | "fullscreen" | "info_pane_open" | "legend_pane_open" | "wrapper" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats">;
 type PhaseDiagram3D = ReturnType<typeof PhaseDiagram3D>;
 export default PhaseDiagram3D;