matterviz 0.3.4 → 0.3.6

package/dist/phase-diagram/parse.js

@@ -1,276 +0,0 @@
-// TDB (Thermodynamic Database) file parser
-// Parses CALPHAD TDB files to extract metadata about elements, phases, and parameters
-import { ELEM_SYMBOLS } from '../labels';
-// Default temperature bounds for TDB parsing (in Kelvin)
-export const TDB_TEMP_DEFAULTS = {
-    min: 298.15, // Room temperature
-    max_fallback: 3000, // Fallback when no functions define ranges
-    max_range: 5000, // Default max for temperature ranges in FUNCTION bodies
-};
-// Parse a TDB file content string
-export function parse_tdb(content) {
-    try {
-        const data = {
-            elements: [],
-            phases: [],
-            functions: [],
-            parameters: [],
-            comments: [],
-            raw_content: content,
-        };
-        // Normalize line endings and join continuation lines
-        const normalized = content
-            .replace(/\r\n/g, `\n`)
-            .replace(/\r/g, `\n`)
-            // Join lines that don't end with ! (continuation)
-            .split(`\n`)
-            .reduce((acc, line) => {
-            const trimmed = line.trim();
-            if (trimmed.startsWith(`$`)) {
-                data.comments.push(trimmed.substring(1).trim());
-                return acc;
-            }
-            if (acc.length === 0 || acc[acc.length - 1].endsWith(`!`)) {
-                acc.push(trimmed);
-            }
-            else {
-                acc[acc.length - 1] += ` ` + trimmed;
-            }
-            return acc;
-        }, [])
-            .filter((line) => line.length > 0);
-        for (const line of normalized) {
-            parse_tdb_line(line, data);
-        }
-        // Derive binary system from elements (excluding VA)
-        const real_elements = data.elements.map((el) => el.symbol).filter(is_real_element);
-        const binary_system = real_elements.length === 2 ? [real_elements[0], real_elements[1]] : undefined;
-        // Extract temperature range from functions/parameters
-        // Find the actual min and max temperatures across all ranges
-        let [min_temp, max_temp] = [Infinity, -Infinity];
-        for (const func of data.functions) {
-            for (const range of func.temperature_ranges) {
-                if (range.min < min_temp)
-                    min_temp = range.min;
-                if (range.max > max_temp)
-                    max_temp = range.max;
-            }
-        }
-        // Use sensible defaults if no ranges found or if extracted range is invalid
-        if (min_temp === Infinity)
-            min_temp = TDB_TEMP_DEFAULTS.min;
-        if (max_temp === -Infinity)
-            max_temp = TDB_TEMP_DEFAULTS.max_fallback;
-        // Ensure min < max (swap if malformed data caused inversion)
-        if (min_temp > max_temp)
-            [min_temp, max_temp] = [max_temp, min_temp];
-        return {
-            success: true,
-            data,
-            binary_system,
-            available_phases: data.phases.map((phase) => phase.name),
-            temperature_range: [min_temp, max_temp],
-        };
-    }
-    catch (exc) {
-        return {
-            success: false,
-            data: null,
-            error: exc instanceof Error ? exc.message : String(exc),
-        };
-    }
-}
-// Line parsers for TDB format - uses a data-driven approach to reduce repetition
-const LINE_PARSERS = [
-    {
-        // ELEMENT AL FCC_A1 2.698154E-02 4.5773304E+03 2.871870E+01!
-        prefix: `ELEMENT `,
-        pattern: /ELEMENT\s+(\S+)\s+(\S+)\s+([\d.E+-]+)\s+([\d.E+-]+)\s+([\d.E+-]+)/i,
-        handler: (match, data) => {
-            data.elements.push({
-                symbol: match[1].toUpperCase(),
-                reference_phase: match[2],
-                mass: parseFloat(match[3]),
-                enthalpy: parseFloat(match[4]),
-                entropy: parseFloat(match[5]),
-            });
-        },
-    },
-    {
-        // PHASE LIQUID % 1 1.0 !
-        prefix: `PHASE `,
-        pattern: /PHASE\s+(\S+)\s+(%\S*)\s+(\d+)\s+(.+?)!/i,
-        handler: (match, data) => {
-            const sublattice_sites = match[4]
-                .trim()
-                .split(/\s+/)
-                .map((val) => parseFloat(val))
-                .filter((val) => !isNaN(val));
-            data.phases.push({
-                name: match[1],
-                model_hints: match[2],
-                sublattice_count: parseInt(match[3], 10),
-                sublattice_sites,
-            });
-        },
-    },
-    {
-        // CONSTITUENT FCC_A1 :AL,ZN : VA : !
-        prefix: `CONSTITUENT `,
-        pattern: /CONSTITUENT\s+(\S+)\s*:\s*(.+?)!/i,
-        handler: (match, data) => {
-            const phase_name = match[1];
-            const constituents = match[2].split(`:`).map((sub) => sub
-                .split(`,`)
-                .map((name) => name.trim())
-                .filter((name) => name.length > 0));
-            const phase = data.phases.find((phase) => phase.name.toUpperCase() === phase_name.toUpperCase());
-            if (phase)
-                phase.constituents = constituents;
-        },
-    },
-    {
-        // FUNCTION GHSERAL 298.15 expr1; 700 Y expr2; 933.47 Y expr3; 2900 N !
-        prefix: `FUNCTION `,
-        pattern: /FUNCTION\s+(\S+)\s+(.+?)!/i,
-        handler: (match, data) => {
-            const ranges = parse_temperature_ranges(match[2]);
-            if (ranges.length > 0) {
-                data.functions.push({
-                    name: match[1],
-                    expression: match[2],
-                    temperature_ranges: ranges,
-                });
-            }
-        },
-    },
-    {
-        // PARAMETER G(LIQUID,AL;0) 298.15 +GHSERAL+11005.029-11.841867*T; 6000 N !
-        prefix: `PARAMETER `,
-        pattern: /PARAMETER\s+(\w+)\(([^)]+)\)\s+(.+?)!/i,
-        handler: (match, data) => {
-            const spec_match = /([^,]+),([^;]+);(\d+)/.exec(match[2]);
-            if (spec_match) {
-                data.parameters.push({
-                    type: match[1],
-                    phase: spec_match[1],
-                    constituents: spec_match[2].split(`,`).map((name) => name.trim()),
-                    order: parseInt(spec_match[3], 10),
-                    expression: match[3],
-                });
-            }
-        },
-    },
-];
-// Parse temperature ranges from FUNCTION body string
-function parse_temperature_ranges(body) {
-    const ranges = [];
-    for (const segment of body.split(/;\s*/)) {
-        const trimmed = segment.trim();
-        if (!trimmed)
-            continue;
-        const temp_match = /^([\d.E+-]+)\s+(.+)/i.exec(trimmed);
-        if (temp_match) {
-            const next_temp = parseFloat(temp_match[1]);
-            const expr = temp_match[2].replace(/\s+[YN]\s*$/, ``).trim();
-            if (ranges.length > 0)
-                ranges[ranges.length - 1].max = next_temp;
-            ranges.push({ min: next_temp, max: TDB_TEMP_DEFAULTS.max_range, expr });
-        }
-    }
-    // Filter out invalid ranges where max <= min (malformed data)
-    return ranges.filter((range) => range.max > range.min);
-}
-function parse_tdb_line(line, data) {
-    const upper_line = line.toUpperCase();
-    for (const parser of LINE_PARSERS) {
-        if (upper_line.startsWith(parser.prefix)) {
-            const match = line.match(parser.pattern);
-            if (match)
-                parser.handler(match, data);
-            else if (parser.prefix === `ELEMENT `) {
-                // Fallback for simpler ELEMENT format: ELEMENT AL FCC_A1!
-                const simple_match = /ELEMENT\s+(\S+)\s+(\S+)/i.exec(line);
-                if (simple_match) {
-                    data.elements.push({
-                        symbol: simple_match[1].toUpperCase(),
-                        reference_phase: simple_match[2].replace(/!$/, ``),
-                        mass: 0,
-                        enthalpy: 0,
-                        entropy: 0,
-                    });
-                }
-            }
-            return;
-        }
-    }
-    // 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(`-`);
-}
-// 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;
-}
-// 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"])
-const KNOWN_ELEMENTS = new Set(ELEM_SYMBOLS.map((sym) => sym.toUpperCase()));
-// Extract element symbols from a concatenated string (e.g., "CuMg" -> ["CU", "MG"])
-// Returns null if the string doesn't fully match as element symbols
-// Uses backtracking to handle ambiguous cases (e.g., "NBR" -> ["N", "BR"] not ["NB", ?])
-function extract_elements_from_string(input) {
-    const upper = input.toUpperCase();
-    function parse(idx) {
-        if (idx >= upper.length)
-            return [];
-        // Try two-letter symbol first (prefer longer match)
-        if (idx + 1 < upper.length) {
-            const two_letter = upper.slice(idx, idx + 2);
-            if (KNOWN_ELEMENTS.has(two_letter)) {
-                const rest = parse(idx + 2);
-                if (rest !== null)
-                    return [two_letter, ...rest];
-            }
-        }
-        // Try single-letter symbol (backtrack if two-letter path failed)
-        const one_letter = upper[idx];
-        if (KNOWN_ELEMENTS.has(one_letter)) {
-            const rest = parse(idx + 1);
-            if (rest !== null)
-                return [one_letter, ...rest];
-        }
-        return null;
-    }
-    const elements = parse(0);
-    return elements && elements.length >= 2 ? elements : null;
-}
-// Normalize a system name string to canonical form (e.g., "cumg", "Cu-Mg", "CU_MG" -> "CU-MG")
-export function normalize_system_name(input) {
-    if (!input)
-        return ``;
-    // First try splitting on common delimiters
-    const delimiter_parts = input.split(/[-_]/).filter(Boolean);
-    let elements;
-    if (delimiter_parts.length >= 2) {
-        // Has delimiter, normalize each part
-        elements = delimiter_parts.map((part) => part.toUpperCase());
-    }
-    else {
-        // No delimiter, try to parse concatenated symbols
-        const parsed = extract_elements_from_string(input);
-        if (!parsed) {
-            // Couldn't parse as elements, return uppercased input as-is
-            return input.toUpperCase();
-        }
-        elements = parsed;
-    }
-    // Sort alphabetically and join with hyphen
-    return elements.sort().join(`-`);
-}

package/dist/phase-diagram/svg-to-diagram.d.ts

@@ -1,2 +0,0 @@
-import type { DiagramInput } from './diagram-input';
-export declare function parse_phase_diagram_svg(svg_string: string): DiagramInput;