matterviz 0.4.0 → 0.4.1

package/dist/composition/parse.js

@@ -1,4 +1,4 @@
-import { element_data } from '../element';
+import { element_data, is_elem_symbol } from '../element';
 import { ELEM_SYMBOLS } from '../labels';
 // Create symbol/number/mass/electronegativity lookup maps for O(1) access
 export const ATOMIC_NUMBER_TO_SYMBOL = {};
@@ -16,8 +16,6 @@ for (const element of element_data) {
     ELEM_NAME_TO_SYMBOL[element.name] = element.symbol;
     ELEM_SYMBOL_TO_NAME[element.symbol] = element.name;
 }
-// Type guard: check if a string is a valid element symbol
-export const is_valid_element = (sym) => ELEM_SYMBOLS.includes(sym);
 // Check if object has atomic numbers as keys (1-118)
 const is_atomic_number_composition = (obj) => {
     const keys = Object.keys(obj);
@@ -51,7 +49,7 @@ export const atomic_num_to_symbols = (atomic_composition) => {
 export const atomic_symbol_to_num = (symbol_composition) => {
     const atomic_composition = {};
     for (const [symbol, amount] of Object.entries(symbol_composition)) {
-        if (!is_valid_element(symbol))
+        if (!is_elem_symbol(symbol))
             throw new Error(`Invalid element symbol: ${symbol}`);
         const atomic_num = SYMBOL_TO_ATOMIC_NUMBER[symbol];
         if (!atomic_num)
@@ -93,7 +91,7 @@ export const parse_formula = (formula) => {
         const expanded = expand_parentheses(segment.slice(coeff?.length ?? 0));
         for (const match of expanded.matchAll(/([A-Z][a-z]?)(\d+(?:\.\d+)?|\.\d+)?/g)) {
             const [, element, count] = match;
-            if (!is_valid_element(element))
+            if (!is_elem_symbol(element))
                 throw new Error(`Invalid element symbol: ${element}`);
             composition[element] = (composition[element] ?? 0) + parse_count(count) * multiplier;
         }
@@ -107,7 +105,7 @@ export const normalize_composition = (composition) => {
     }
     const normalized = {};
     for (const [element, amount] of Object.entries(composition)) {
-        if (typeof amount === `number` && amount > 0 && is_valid_element(element)) {
+        if (typeof amount === `number` && amount > 0 && is_elem_symbol(element)) {
             normalized[element] = amount;
         }
     }
@@ -125,7 +123,7 @@ export const sanitize_composition_keys = (composition) => {
         if (typeof amount !== `number` || amount <= 0)
             continue;
         // Extract first valid element symbol from key (e.g. "B0." -> "B", "Fe2+" -> "Fe")
-        const elem = (key.match(/[A-Z][a-z]?/g) ?? []).find(is_valid_element);
+        const elem = (key.match(/[A-Z][a-z]?/g) ?? []).find(is_elem_symbol);
         if (elem)
             sanitized[elem] = (sanitized[elem] || 0) + amount;
     }
@@ -139,7 +137,7 @@ export const fractional_composition = (composition, by_weight = false) => {
     const filtered = Object.fromEntries(Object.entries(composition).filter(([, amount]) => amount > 0));
     if (by_weight) {
         const element_weights = Object.fromEntries(Object.entries(filtered).map(([element, amount]) => {
-            if (!is_valid_element(element))
+            if (!is_elem_symbol(element))
                 throw new Error(`Unknown element: ${element}`);
             const atomic_mass = ATOMIC_WEIGHTS.get(element);
             if (!atomic_mass)
@@ -191,14 +189,14 @@ export const get_reduced_formula = (composition) => {
         return composition;
     const reduced = {};
     for (const [elem, amt] of Object.entries(composition)) {
-        if (is_valid_element(elem))
+        if (is_elem_symbol(elem))
             reduced[elem] = amt / divisor;
     }
     return reduced;
 };
 // Calculate molecular weight (sum of atomic masses * amounts)
 export const get_molecular_weight = (composition) => Object.entries(composition).reduce((total, [elem, amount]) => {
-    const mass = is_valid_element(elem) ? (ATOMIC_WEIGHTS.get(elem) ?? 0) : 0;
+    const mass = is_elem_symbol(elem) ? (ATOMIC_WEIGHTS.get(elem) ?? 0) : 0;
     return total + mass * amount;
 }, 0);
 // Parse oxidation state string (e.g. "+2", "2+", "-", "[2-]") to number
@@ -241,7 +239,7 @@ export const parse_formula_with_oxidation = (formula, strict = false) => {
         const oxidation_str = match[2] || match[3] || match[6] || match[7];
         const count_str = match[4] || match[5];
         const count = parse_count(count_str);
-        if (!is_valid_element(element))
+        if (!is_elem_symbol(element))
             throw new Error(`Invalid element symbol: ${element}`);
         const oxidation_state = oxidation_str ? parse_oxidation_state(oxidation_str) : undefined;
         // Find or add element entry
@@ -269,7 +267,7 @@ export const parse_formula_with_oxidation = (formula, strict = false) => {
 };
 // Convert OxiComposition to ElementWithOxidation array
 // Does not preserve original order since objects don't have a defined order
-export const oxi_composition_to_elements = (composition) => Object.entries(composition).flatMap(([element, { amount, oxidation_state }], idx) => is_valid_element(element) ? [{ element, amount, oxidation_state, orig_idx: idx }] : []);
+export const oxi_composition_to_elements = (composition) => Object.entries(composition).flatMap(([element, { amount, oxidation_state }], idx) => is_elem_symbol(element) ? [{ element, amount, oxidation_state, orig_idx: idx }] : []);
 // Extract element symbols from a chemical formula.
 // Default (unique=true, sorted=true): "NbZr2Nb" -> ["Nb", "Zr"]
 // unique=false: Fast token extraction preserving order without parentheses expansion
@@ -283,12 +281,12 @@ export function extract_formula_elements(formula, { unique = true, sorted = true
         const matches = formula.match(/[A-Z][a-z]?/g) ?? [];
         const elements = [];
         for (const match of matches) {
-            if (is_valid_element(match))
+            if (is_elem_symbol(match))
                 elements.push(match);
         }
         return elements;
     }
-    const symbols = Object.keys(parse_formula(formula)).filter(is_valid_element);
+    const symbols = Object.keys(parse_formula(formula)).filter(is_elem_symbol);
     return sorted ? symbols.sort() : symbols;
 }
 // Generate all non-empty subsets of a chemical system as hyphenated strings.
@@ -302,7 +300,7 @@ export function generate_chem_sys_subspaces(input) {
     else if (Array.isArray(input)) {
         const uniq = [...new Set(input)];
         for (const elem of uniq) {
-            if (!is_valid_element(elem))
+            if (!is_elem_symbol(elem))
                 throw new Error(`Invalid element symbol: ${elem}`);
         }
         elements = uniq;
@@ -310,7 +308,7 @@ export function generate_chem_sys_subspaces(input) {
     else {
         elements = [];
         for (const elem of Object.keys(input)) {
-            if (!is_valid_element(elem))
+            if (!is_elem_symbol(elem))
                 throw new Error(`Invalid element symbol: ${elem}`);
             elements.push(elem);
         }
@@ -354,7 +352,7 @@ export function parse_chemsys_with_wildcards(input) {
         if (token === `*`) {
             wildcard_count++;
         }
-        else if (is_valid_element(token)) {
+        else if (is_elem_symbol(token)) {
             elements.push(token);
         }
         else {
@@ -401,7 +399,7 @@ export function parse_formula_with_wildcards(formula) {
             // Element symbol match
             const element = match[1];
             const count = parse_count(match[2]);
-            if (!is_valid_element(element)) {
+            if (!is_elem_symbol(element)) {
                 throw new Error(`Invalid element symbol: ${element}`);
             }
             tokens.push({ element, count });
@@ -422,7 +420,7 @@ export function matches_chemsys_wildcard(formula, explicit_elements, wildcard_co
         // Must contain all explicit elements
         const formula_set = new Set(formula_elements);
         for (const elem of explicit_elements) {
-            if (!is_valid_element(elem) || !formula_set.has(elem))
+            if (!is_elem_symbol(elem) || !formula_set.has(elem))
                 return false;
         }
         return true;

package/dist/controls.d.ts

@@ -5,6 +5,7 @@ export type ShowControlsConfig = {
     style?: string;
 };
 export type ShowControlsProp = ControlsVisibility | ShowControlsConfig | boolean;
+export type ShowControlsState = ReturnType<typeof normalize_show_controls>;
 export declare function normalize_show_controls(prop: ShowControlsProp | undefined): {
     mode: ControlsVisibility;
     hidden: Set<string>;

package/dist/controls.js

@@ -1,6 +1,5 @@
 // Controls visibility configuration for visualization components
 // Manages visibility of control buttons in Structure, Trajectory, BrillouinZone
-// Normalize show_controls prop into consistent config with helper methods
 export function normalize_show_controls(prop) {
     // Extract mode, hidden, style from various prop forms
     let mode = `hover`;

package/dist/convex-hull/ConvexHull.svelte

@@ -8,17 +8,13 @@
   import ConvexHull3D from './ConvexHull3D.svelte'
   import ConvexHull4D from './ConvexHull4D.svelte'
   import type { BaseConvexHullProps, Hull3DProps } from './index'
-  import type { GasSpecies, GasThermodynamicsConfig } from './types'
 
   // Union type combining all possible props from 2D, 3D, and 4D components
   // each specific component will only use its relevant props from this super set
+  // (gas_config/gas_pressures already come from BaseConvexHullProps)
   type ConvexHullProps = BaseConvexHullProps & Hull3DProps & {
     x_axis?: AxisConfig
     y_axis?: AxisConfig
-    // Gas thermodynamics config - enables atmosphere-controlled phase diagrams
-    gas_config?: GasThermodynamicsConfig
-    // Gas pressure binding - enables two-way binding for atmosphere control
-    gas_pressures?: Partial<Record<GasSpecies, number>>
   }
 
   let {
@@ -28,6 +24,7 @@
     wrapper = $bindable(),
     show_stable = $bindable(true),
     show_unstable = $bindable(true),
+    hidden_categories = $bindable([]),
     show_hull_faces = $bindable(true),
     hull_face_opacity: hull_face_opacity_prop = $bindable(
       undefined as number | undefined,
@@ -35,7 +32,7 @@
     color_mode = $bindable(`energy`),
     color_scale = $bindable(`interpolateViridis`),
     info_pane_open = $bindable(false),
-    legend_pane_open = $bindable(false),
+    controls_open = $bindable(false),
     max_hull_dist_show_phases = $bindable(0.1),
     max_hull_dist_show_labels = $bindable(0.1),
     show_stable_labels = $bindable(true),
@@ -87,9 +84,9 @@
     hull_face_opacity_prop = hull_face_opacity
   })
 
-  // Map element count to corresponding component
-  // Note: Type assertion needed because TypeScript can't infer that all components
-  // accept a compatible superset of props (BaseConvexHullProps + dimension-specific)
+  // Map element count to component. Deliberate cast: the wrapper passes the prop superset
+  // while each component declares only its dimension's props (2D lacks Hull3DProps, 3D/4D
+  // lack x/y_axis), so a constructor union wouldn't compile. Svelte ignores extra props.
   const ConvexHullComponent = $derived(
     { 2: ConvexHull2D, 3: ConvexHull3D, 4: ConvexHull4D }[element_count] ??
       null,
@@ -104,12 +101,13 @@
     bind:wrapper
     bind:show_stable
     bind:show_unstable
+    bind:hidden_categories
     bind:show_hull_faces
     bind:hull_face_opacity
     bind:color_mode
     bind:color_scale
     bind:info_pane_open
-    bind:legend_pane_open
+    bind:controls_open
     bind:max_hull_dist_show_phases
     bind:max_hull_dist_show_labels
     bind:show_stable_labels

package/dist/convex-hull/ConvexHull.svelte.d.ts

@@ -1,13 +1,10 @@
 import type { AxisConfig } from '../plot';
 import type { Component } from 'svelte';
 import type { BaseConvexHullProps, Hull3DProps } from './index';
-import type { GasSpecies, GasThermodynamicsConfig } from './types';
 type ConvexHullProps = BaseConvexHullProps & Hull3DProps & {
     x_axis?: AxisConfig;
     y_axis?: AxisConfig;
-    gas_config?: GasThermodynamicsConfig;
-    gas_pressures?: Partial<Record<GasSpecies, number>>;
 };
-declare const ConvexHull: Component<ConvexHullProps, {}, "temperature" | "display" | "fullscreen" | "show_hull_faces" | "hull_face_opacity" | "color_mode" | "color_scale" | "show_stable" | "show_unstable" | "show_stable_labels" | "show_unstable_labels" | "max_hull_dist_show_phases" | "max_hull_dist_show_labels" | "info_pane_open" | "legend_pane_open" | "wrapper" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats" | "highlighted_entries" | "selected_entry" | "gas_pressures">;
+declare const ConvexHull: Component<ConvexHullProps, {}, "display" | "temperature" | "fullscreen" | "wrapper" | "controls_open" | "color_scale" | "info_pane_open" | "show_hull_faces" | "hull_face_opacity" | "color_mode" | "show_stable" | "show_unstable" | "show_stable_labels" | "show_unstable_labels" | "max_hull_dist_show_phases" | "max_hull_dist_show_labels" | "hidden_categories" | "energy_source_mode" | "stable_entries" | "unstable_entries" | "phase_stats" | "highlighted_entries" | "selected_entry" | "gas_pressures">;
 type ConvexHull = ReturnType<typeof ConvexHull>;
 export default ConvexHull;