matterviz 0.3.5 → 0.3.7

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

@@ -1,6 +1,7 @@
-import type { CompUnit, PseudoBinaryMetadata, SpecialPointType, TempUnit } from './types';
-export type DiagramPoint = [number, number];
-export type TempRange = [number, number];
+import type { Vec2 } from '../math';
+import type { CompUnit, PseudoBinaryMetadata, SpecialPoint, TempUnit } from './types';
+export type DiagramPoint = Vec2;
+export type TempRange = Vec2;
 export type BoundElement = string | DiagramPoint;
 export interface DiagramInputMeta {
     components: [string, string];
@@ -19,12 +20,7 @@ export interface RegionInput {
     bounds: BoundElement[];
     label_position?: DiagramPoint;
 }
-export interface SpecialPointInput {
-    id: string;
-    type: SpecialPointType;
-    position: DiagramPoint;
-    label?: string;
-}
+export type SpecialPointInput = SpecialPoint;
 export interface DiagramInput {
     meta: DiagramInputMeta;
     curves: Record<string, DiagramPoint[]>;

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

@@ -1,6 +1,6 @@
 export { build_diagram } from './build-diagram';
 export * from './colors';
-export * from './diagram-input';
+export type * from './diagram-input';
 export { default as IsobaricBinaryPhaseDiagram } from './IsobaricBinaryPhaseDiagram.svelte';
 export * from './parse';
 export { default as PhaseDiagramControls } from './PhaseDiagramControls.svelte';
@@ -9,5 +9,5 @@ export { default as PhaseDiagramExportPane } from './PhaseDiagramExportPane.svel
 export { default as PhaseDiagramTooltip } from './PhaseDiagramTooltip.svelte';
 export { parse_phase_diagram_svg } from './svg-to-diagram';
 export { default as TdbInfoPanel } from './TdbInfoPanel.svelte';
-export * from './types';
+export type * from './types';
 export * from './utils';

package/dist/phase-diagram/index.js

@@ -1,6 +1,5 @@
 export { build_diagram } from './build-diagram';
 export * from './colors';
-export * from './diagram-input';
 export { default as IsobaricBinaryPhaseDiagram } from './IsobaricBinaryPhaseDiagram.svelte';
 export * from './parse';
 export { default as PhaseDiagramControls } from './PhaseDiagramControls.svelte';
@@ -9,5 +8,4 @@ export { default as PhaseDiagramExportPane } from './PhaseDiagramExportPane.svel
 export { default as PhaseDiagramTooltip } from './PhaseDiagramTooltip.svelte';
 export { parse_phase_diagram_svg } from './svg-to-diagram';
 export { default as TdbInfoPanel } from './TdbInfoPanel.svelte';
-export * from './types';
 export * from './utils';

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

@@ -50,6 +50,6 @@ export interface TdbParseResult {
     temperature_range?: [number, number];
 }
 export declare function parse_tdb(content: string): TdbParseResult;
-export declare function get_system_name(elements: string[]): string;
-export declare function is_binary_system(tdb_data: TdbData): boolean;
+export declare const get_system_name: (elements: string[]) => string;
+export declare const is_binary_system: (tdb_data: TdbData) => boolean;
 export declare function normalize_system_name(input: string): string;

package/dist/phase-diagram/parse.js

@@ -207,17 +207,13 @@ function parse_tdb_line(line, data) {
     // TYPE_DEFINITION, DEFINE_SYSTEM_DEFAULT, etc. are ignored
 }
 // Get a normalized system name from elements (e.g., "AL-ZN" always alphabetically sorted)
-export function get_system_name(elements) {
-    return elements
-        .filter(is_real_element)
-        .map((el) => el.toUpperCase())
-        .sort()
-        .join(`-`);
-}
+export const get_system_name = (elements) => elements
+    .filter(is_real_element)
+    .map((el) => el.toUpperCase())
+    .sort()
+    .join(`-`);
 // Check if a TDB file represents a binary system
-export function is_binary_system(tdb_data) {
-    return tdb_data.elements.map((el) => el.symbol).filter(is_real_element).length === 2;
-}
+export const is_binary_system = (tdb_data) => tdb_data.elements.map((el) => el.symbol).filter(is_real_element).length === 2;
 // Predicate to filter out non-real elements (VA = vacancy, /- = electron)
 const is_real_element = (sym) => sym !== `VA` && sym !== `/-`;
 // Known element symbols for parsing concatenated system names (e.g., "CuMg" -> ["CU", "MG"])

package/dist/phase-diagram/svg-to-diagram.js

@@ -124,10 +124,10 @@ function extract_mpds_scales(doc) {
     // Note: value 100 appears in both filters (valid as 100 at% and 100°C).
     // This is intentional — only endpoints are used for scale mapping.
     const comp_vals = [
-        ...new Set(numbers.filter((v) => v >= 0 && v <= 100 && v % 10 === 0)),
+        ...new Set(numbers.filter((value) => value >= 0 && value <= 100 && value % 10 === 0)),
     ].toSorted((a, b) => a - b);
     const temp_vals = [
-        ...new Set(numbers.filter((v) => v >= 100 && v % 100 === 0 && v <= 3000)),
+        ...new Set(numbers.filter((value) => value >= 100 && value % 100 === 0 && value <= 3000)),
     ].toSorted((a, b) => a - b);
     if (comp_vals.length < 2 || temp_vals.length < 2) {
         throw new Error(`MPDS SVG: could not infer axis ranges (found ${comp_vals.length} composition, ${temp_vals.length} temperature values)`);
@@ -164,10 +164,10 @@ function extract_mpds_scales(doc) {
     }
     // Deduplicate and sort
     const x_ticks_sorted = [
-        ...new Set(x_major_ticks.map((v) => Math.round(v * 10) / 10)),
+        ...new Set(x_major_ticks.map((value) => Math.round(value * 10) / 10)),
     ].toSorted((a, b) => a - b);
     const y_ticks_sorted = [
-        ...new Set(y_major_ticks.map((v) => Math.round(v * 10) / 10)),
+        ...new Set(y_major_ticks.map((value) => Math.round(value * 10) / 10)),
     ].toSorted((a, b) => a - b);
     if (x_ticks_sorted.length < 2 || y_ticks_sorted.length < 2) {
         throw new Error(`MPDS SVG: could not find tick marks (found ${x_ticks_sorted.length} x-ticks, ${y_ticks_sorted.length} y-ticks)`);
@@ -432,45 +432,45 @@ function extract_simple_labels(doc, labels) {
     }
 }
 // === Component Inference ===
+const split_phase_label = (label) => label.text.split(/\s*\+\s*/);
 // Infer binary components from region labels
 function infer_components(labels) {
     // Sort labels by x position, split each into phases
     const sorted = labels.toSorted((a, b) => a.px_x - b.px_x);
     if (sorted.length < 2)
         return [`A`, `B`];
-    const split = (label) => label.text.split(/\s*\+\s*/);
-    const leftmost = split(sorted[0]);
-    const rightmost = split(sorted[sorted.length - 1]);
+    const leftmost = split_phase_label(sorted[0]);
+    const rightmost = split_phase_label(sorted[sorted.length - 1]);
     // Component A: the unique phase in the leftmost region that doesn't appear on the right
     // For "La2NiO4 + La2O3", La2O3 is the pure A endpoint
     let comp_a = `A`;
     if (leftmost.length === 2) {
-        const right_phases = new Set(sorted.slice(-3).flatMap(split));
-        comp_a = leftmost.find((p) => !right_phases.has(p)) ?? leftmost[1] ?? `A`;
+        const right_phases = new Set(sorted.slice(-3).flatMap(split_phase_label));
+        comp_a = leftmost.find((phase) => !right_phases.has(phase)) ?? leftmost[1] ?? `A`;
     }
     // Component B: the unique phase in the rightmost region that doesn't appear on the left
     let comp_b = `B`;
     if (rightmost.length === 2) {
-        const left_phases = new Set(sorted.slice(0, 3).flatMap(split));
-        comp_b = rightmost.find((p) => !left_phases.has(p)) ?? rightmost[1] ?? `B`;
+        const left_phases = new Set(sorted.slice(0, 3).flatMap(split_phase_label));
+        comp_b = rightmost.find((phase) => !left_phases.has(phase)) ?? rightmost[1] ?? `B`;
     }
     return [comp_a, comp_b];
 }
 // === Region Inference ===
 // Infer phase regions from orthogonal boundaries using flood-fill on a cell grid
 function infer_regions(boundaries, labels, x_scale, y_scale) {
-    const verticals = boundaries.filter((b) => b.orientation === `vertical`);
-    const horizontals = boundaries.filter((b) => b.orientation === `horizontal`);
+    const verticals = boundaries.filter((boundary) => boundary.orientation === `vertical`);
+    const horizontals = boundaries.filter((boundary) => boundary.orientation === `horizontal`);
     // Collect all unique x and y coordinates (boundaries + domain edges)
     const x_coords = collect_unique_sorted([
         x_scale.domain[0],
         x_scale.domain[1],
-        ...verticals.map((b) => b.x1), // x1 === x2 for vertical
+        ...verticals.map((boundary) => boundary.x1), // x1 === x2 for vertical
     ]);
     const y_coords = collect_unique_sorted([
         y_scale.domain[0],
         y_scale.domain[1],
-        ...horizontals.map((b) => b.y1), // y1 === y2 for horizontal
+        ...horizontals.map((boundary) => boundary.y1), // y1 === y2 for horizontal
     ]);
     // Build cell grid: cells[col][row]
     const n_cols = x_coords.length - 1;

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

@@ -1,6 +1,7 @@
-import type { Sides } from '../plot';
+import type { Point2D, Vec2 } from '../math';
+import type { LineStyle } from '../plot';
+import type { Sides } from '../plot/layout';
 import type { TooltipConfig, TooltipProp } from '../tooltip';
-import type { Vec2 } from '../math.ts';
 export type TempUnit = `K` | `°C` | `°F`;
 export type CompUnit = `at%` | `wt%` | `mol%` | `fraction`;
 export interface PhaseRegion {
@@ -15,11 +16,7 @@ export interface PhaseBoundary {
     id: string;
     type: BoundaryType;
     points: Vec2[];
-    style?: {
-        color?: string;
-        width?: number;
-        dash?: string;
-    };
+    style?: LineStyle;
     label?: string;
 }
 export type SpecialPointType = `eutectic` | `peritectic` | `eutectoid` | `peritectoid` | `congruent` | `melting_point` | `custom`;
@@ -87,10 +84,7 @@ export interface PhaseHoverInfo {
     region: PhaseRegion;
     composition: number;
     temperature: number;
-    position: {
-        x: number;
-        y: number;
-    };
+    position: Point2D;
     lever_rule?: LeverRuleResult;
     vertical_lever_rule?: VerticalLeverRuleResult;
     special_point?: SpecialPoint;

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

@@ -1,5 +1,5 @@
 import { type Vec2 } from '../math';
-import type { Sides } from '../plot';
+import type { Sides } from '../plot/layout';
 import type { CompUnit, LeverRuleMode, LeverRuleResult, PhaseDiagramConfig, PhaseDiagramData, PhaseHoverInfo, PhaseRegion, TempUnit, VerticalLeverRuleResult } from './types';
 export declare function convert_temp(value: number, from: TempUnit, to: TempUnit): number;
 export declare const PHASE_DIAGRAM_DEFAULTS: Readonly<{
@@ -89,7 +89,7 @@ export declare function compute_label_properties(label: string, bounds: {
     lines: string[];
     scale: number;
 };
-export declare function transform_vertices(vertices: Vec2[], x_scale: (val: number) => number, y_scale: (val: number) => number): Vec2[];
+export declare const transform_vertices: (vertices: Vec2[], x_scale: (val: number) => number, y_scale: (val: number) => number) => Vec2[];
 export declare function format_composition(value: number, unit?: CompUnit, include_unit?: boolean): string;
 export declare function format_temperature(value: number, unit?: TempUnit): string;
 export declare function calculate_lever_rule(region: PhaseRegion, composition: number, temperature: number): LeverRuleResult | null;

package/dist/phase-diagram/utils.js

@@ -76,10 +76,10 @@ export const PHASE_COLOR_HEX = {
 };
 // Derive RGB string format (e.g. "135, 206, 250") for custom alpha usage
 export const PHASE_COLOR_RGB = Object.freeze(Object.fromEntries(Object.entries(PHASE_COLOR_HEX).map(([key, hex]) => {
-    const r = parseInt(hex.slice(1, 3), 16);
-    const g = parseInt(hex.slice(3, 5), 16);
-    const b = parseInt(hex.slice(5, 7), 16);
-    return [key, `${r}, ${g}, ${b}`];
+    const red = parseInt(hex.slice(1, 3), 16);
+    const green = parseInt(hex.slice(3, 5), 16);
+    const blue = parseInt(hex.slice(5, 7), 16);
+    return [key, `${red}, ${green}, ${blue}`];
 })));
 // Derive rgba() format with default alpha using add_alpha
 const PHASE_ALPHA = { two_phase: 0.5, default: 0.5, tie_line: 1 };
@@ -109,7 +109,7 @@ export function get_phase_color_key(name) {
     if (lower === `l`)
         return `liquid`; // exact match for shorthand "L"
     for (const [patterns, key, prefix] of PHASE_PATTERNS) {
-        if (patterns.some((p) => lower.includes(p)))
+        if (patterns.some((pattern) => lower.includes(pattern)))
             return key;
         if (prefix && lower.startsWith(prefix))
             return key;
@@ -129,7 +129,7 @@ export function get_multi_phase_gradient(name) {
         return null;
     const phases = name
         .split(`+`)
-        .map((s) => s.trim())
+        .map((phase) => phase.trim())
         .filter(Boolean);
     if (phases.length < 2)
         return null;
@@ -152,8 +152,8 @@ export function find_phase_at_point(composition, temperature, data) {
 }
 // SVG path generator using d3-shape
 const path_line = line()
-    .x((d) => d[0])
-    .y((d) => d[1]);
+    .x((point) => point[0])
+    .y((point) => point[1]);
 // Generate closed SVG path for polygon regions (min 3 points)
 export const generate_region_path = (vertices) => vertices.length < 3 ? `` : `${path_line(vertices)} Z`;
 // Generate open SVG path for boundary curves (min 2 points)
@@ -222,9 +222,7 @@ function wrap_text(text, max_chars) {
     return lines;
 }
 // Transform data coordinates to SVG coordinates using scale functions
-export function transform_vertices(vertices, x_scale, y_scale) {
-    return vertices.map(([comp, temp]) => [x_scale(comp), y_scale(temp)]);
-}
+export const transform_vertices = (vertices, x_scale, y_scale) => vertices.map(([comp, temp]) => [x_scale(comp), y_scale(temp)]);
 // Format composition value for display
 export function format_composition(value, unit = `at%`, include_unit = true) {
     if (unit === `fraction`)