matterviz 0.3.1 → 0.3.3

package/dist/chempot-diagram/ChemPotDiagram3D.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { PhaseData } from '../convex-hull/types';
+import type { ChemPotDiagramConfig, ChemPotHoverInfo } from './types';
+type $$ComponentProps = {
+    entries: PhaseData[];
+    config?: ChemPotDiagramConfig;
+    width?: number;
+    height?: number;
+    temperature?: number;
+    interpolate_temperature?: boolean;
+    max_interpolation_gap?: number;
+    hover_info?: ChemPotHoverInfo | null;
+    render_local_tooltip?: boolean;
+};
+declare const ChemPotDiagram3D: import("svelte").Component<$$ComponentProps, {}, "temperature" | "height" | "width" | "hover_info">;
+type ChemPotDiagram3D = ReturnType<typeof ChemPotDiagram3D>;
+export default ChemPotDiagram3D;

package/dist/chempot-diagram/ChemPotScene3D.svelte

@@ -0,0 +1,11 @@
+<script lang="ts">
+  // Scene wrapper that enables Threlte pointer events for hover tooltips.
+  // Must be rendered inside <Canvas>, mirroring ScatterPlot3DScene / StructureScene pattern.
+  import { interactivity } from '@threlte/extras'
+  import type { Snippet } from 'svelte'
+
+  let { children }: { children?: Snippet } = $props()
+  interactivity()
+</script>
+
+{@render children?.()}

package/dist/chempot-diagram/ChemPotScene3D.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { Snippet } from 'svelte';
+type $$ComponentProps = {
+    children?: Snippet;
+};
+declare const ChemPotScene3D: import("svelte").Component<$$ComponentProps, {}, "">;
+type ChemPotScene3D = ReturnType<typeof ChemPotScene3D>;
+export default ChemPotScene3D;

package/dist/chempot-diagram/async-compute.svelte.d.ts

@@ -0,0 +1,3 @@
+import type { ChemPotDiagramConfig, ChemPotDiagramData } from './types';
+import type { PhaseData } from '../convex-hull/types';
+export declare function compute_chempot_async(entries: PhaseData[], config?: ChemPotDiagramConfig): Promise<ChemPotDiagramData>;

package/dist/chempot-diagram/async-compute.svelte.js

@@ -0,0 +1,77 @@
+// Async wrapper for compute_chempot_diagram via Web Worker.
+// Falls back to synchronous main-thread computation during SSR.
+import { compute_chempot_diagram, formula_key_from_composition } from './compute';
+let worker = null;
+let next_id = 0;
+const pending = new Map();
+const pending_by_key = new Map();
+function make_compute_request_key(entries, config) {
+    const keyed_entries = entries
+        .map((entry) => [
+        formula_key_from_composition(entry.composition),
+        entry.energy,
+        entry.energy_per_atom ?? ``,
+        entry.e_form_per_atom ?? ``,
+        entry.is_stable ?? ``,
+        entry.e_above_hull ?? ``,
+        entry.exclude_from_hull ?? ``,
+    ].join(`:`))
+        .sort();
+    return `${keyed_entries.join(`,`)}|${JSON.stringify(config)}`;
+}
+function track_pending(request_key, promise) {
+    pending_by_key.set(request_key, promise);
+    promise.then(() => pending_by_key.delete(request_key), () => pending_by_key.delete(request_key));
+    return promise;
+}
+function get_worker() {
+    if (typeof Worker === `undefined`)
+        return null;
+    if (!worker) {
+        worker = new Worker(new URL(`./chempot-worker.ts`, import.meta.url), { type: `module` });
+        worker.onmessage = ({ data: { id, result, error } }) => {
+            const req = pending.get(id);
+            if (!req)
+                return;
+            pending.delete(id);
+            if (error || !result)
+                req.reject(new Error(error ?? `Worker returned null`));
+            else
+                req.resolve(result);
+        };
+        worker.onerror = (event) => {
+            event.preventDefault();
+            const err = new Error(event.message || `Worker initialization error`);
+            for (const req of pending.values())
+                req.reject(err);
+            pending.clear();
+            worker = null;
+        };
+    }
+    return worker;
+}
+export function compute_chempot_async(entries, config = {}) {
+    const request_key = make_compute_request_key(entries, config);
+    const existing = pending_by_key.get(request_key);
+    if (existing)
+        return existing;
+    const wkr = get_worker();
+    // SSR / no-Worker fallback: run synchronously (wrapped so throws → rejections)
+    if (!wkr) {
+        const promise = Promise.resolve().then(() => compute_chempot_diagram(entries, config));
+        return track_pending(request_key, promise);
+    }
+    const promise = new Promise((resolve, reject) => {
+        const id = ++next_id;
+        pending.set(id, { resolve, reject });
+        try {
+            // $state.snapshot strips Svelte $state proxies (not structured-cloneable)
+            wkr.postMessage($state.snapshot({ id, entries, config }));
+        }
+        catch (err) {
+            pending.delete(id);
+            reject(err instanceof Error ? err : new Error(String(err)));
+        }
+    });
+    return track_pending(request_key, promise);
+}

package/dist/chempot-diagram/chempot-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/chempot-diagram/chempot-worker.js

@@ -0,0 +1,11 @@
+import { compute_chempot_diagram } from './compute';
+self.onmessage = (event) => {
+    const { id, entries, config } = event.data;
+    try {
+        const result = compute_chempot_diagram(entries, config);
+        postMessage({ id, result, error: null });
+    }
+    catch (err) {
+        postMessage({ id, result: null, error: err instanceof Error ? err.message : String(err) });
+    }
+};

package/dist/chempot-diagram/color.d.ts

@@ -0,0 +1,10 @@
+import { type D3InterpolateName } from '../colors';
+/** Resolve D3 interpolator with optional reverse for chempot color scales. */
+export declare function get_chempot_interpolator(name: D3InterpolateName, reverse: boolean): (t: number) => string;
+/** Build sequential color scale from values and D3 interpolator name. */
+export declare function make_chempot_color_scale(values: number[], interpolator_name: D3InterpolateName, reverse: boolean): ((val: number) => string) | null;
+/** Resolve color bar props for chempot diagrams (interpolator + domain). */
+export declare function get_chempot_color_bar_config(color_scale: D3InterpolateName, reverse: boolean): {
+    color_scale_fn: (t: number) => string;
+    color_scale_domain: [number, number];
+};

package/dist/chempot-diagram/color.js

@@ -0,0 +1,32 @@
+import { get_d3_interpolator } from '../colors';
+import { scaleSequential } from 'd3-scale';
+/** Resolve D3 interpolator with optional reverse for chempot color scales. */
+export function get_chempot_interpolator(name, reverse) {
+    const raw = get_d3_interpolator(name);
+    return reverse ? (t) => raw(1 - t) : raw;
+}
+/** Build sequential color scale from values and D3 interpolator name. */
+export function make_chempot_color_scale(values, interpolator_name, reverse) {
+    const finite_values = values.filter(Number.isFinite);
+    if (finite_values.length === 0)
+        return null;
+    let [min_value, max_raw_value] = [finite_values[0], finite_values[0]];
+    for (let idx = 1; idx < finite_values.length; idx++) {
+        if (finite_values[idx] < min_value)
+            min_value = finite_values[idx];
+        if (finite_values[idx] > max_raw_value)
+            max_raw_value = finite_values[idx];
+    }
+    const max_value = Math.max(max_raw_value, min_value + 1e-6);
+    return scaleSequential(get_chempot_interpolator(interpolator_name, reverse)).domain([
+        min_value,
+        max_value,
+    ]);
+}
+/** Resolve color bar props for chempot diagrams (interpolator + domain). */
+export function get_chempot_color_bar_config(color_scale, reverse) {
+    return {
+        color_scale_fn: get_chempot_interpolator(color_scale, reverse),
+        color_scale_domain: [0, 1],
+    };
+}

package/dist/chempot-diagram/compute.d.ts

@@ -0,0 +1,48 @@
+import type { PhaseData } from '../convex-hull/types';
+import { type ChemPotDiagramConfig, type ChemPotDiagramData } from './types';
+export declare function get_energy_per_atom(entry: PhaseData): number;
+export declare function formula_key_from_composition(composition: Record<string, number>): string;
+export declare function get_min_entries_and_el_refs(entries: PhaseData[]): {
+    min_entries: PhaseData[];
+    el_refs: Record<string, PhaseData>;
+};
+export declare function compute_form_energy_per_atom(entry: PhaseData, el_refs: Record<string, PhaseData>): number;
+export declare function best_form_energy_for_formula(entries: PhaseData[], formula: string, el_refs: Record<string, PhaseData>): number | undefined;
+export declare function renormalize_entries(entries: PhaseData[], el_refs: Record<string, PhaseData>, elements: string[]): PhaseData[];
+export declare function build_hyperplanes(min_entries: PhaseData[], el_refs: Record<string, PhaseData>, elements: string[]): {
+    hyperplanes: number[][];
+    hyperplane_entries: PhaseData[];
+};
+export declare function build_border_hyperplanes(lims: [number, number][]): number[][];
+export declare function compute_domains(hyperplanes: number[][], border_hyperplanes: number[][], hyperplane_entries: PhaseData[], dim: number): Record<string, number[][]>;
+export declare function apply_element_padding(domains: Record<string, number[][]>, elem_indices: number[], padding: number, default_min_limit: number): number[];
+export declare function pad_domain_points(pts: number[][], elem_indices: number[], new_lims: number[], default_min_limit: number, padding: number): number[][];
+export declare function build_axis_ranges(points: number[][], elements: string[]): {
+    element: string;
+    min_val: number;
+    max_val: number;
+}[];
+export declare function simple_pca(data: number[][], k?: number): {
+    scores: number[][];
+    eigenvectors: number[][];
+};
+export declare function orthonormal_2d(line_pts: number[][]): [number, number];
+export declare function dedup_points(pts: number[][], tol?: number): {
+    unique: number[][];
+    orig_indices: number[];
+};
+export declare function get_3d_domain_simplexes_and_ann_loc(points_3d: number[][]): {
+    simplex_indices: number[][];
+    ann_loc: number[];
+};
+export declare function bbox_diagonal(points: number[][]): number;
+export declare function scale_to_font_range(sizes: number[], min_font: number, max_font: number): number[];
+export interface VisibleDomainLabel {
+    formula: string;
+    position: [number, number, number];
+    label_font_size: number;
+}
+export declare function get_visible_domain_labels(face_positions: ArrayLike<number>, face_domain_map: string[], label_font_size_by_formula: ReadonlyMap<string, number>, pinned_labels?: VisibleDomainLabel[]): VisibleDomainLabel[];
+export declare function get_ternary_combinations(elements: string[]): string[][];
+export declare function make_nd_cache_key(entries: PhaseData[], formal_chempots: boolean, default_min_limit: number, limits: ChemPotDiagramConfig[`limits`]): string;
+export declare function compute_chempot_diagram(entries: PhaseData[], config?: ChemPotDiagramConfig): ChemPotDiagramData;