matterviz 0.3.5 → 0.3.7

package/dist/MillerIndexInput.svelte

@@ -7,7 +7,7 @@
 
   // Format: compact "001" for single-digit, spaced "10 0 1" for multi-digit
   let hkl_text = $derived(
-    value.every((v) => Math.abs(v) < 10) ? value.join(``) : value.join(` `),
+    value.every((component) => Math.abs(component) < 10) ? value.join(``) : value.join(` `),
   )
 
   // Parse hkl string: supports compact "001"/"-101" and spaced/comma "10, 0, 1"
@@ -16,7 +16,7 @@
     const spaced = input.trim().split(/[,\s]+/)
     if (spaced.length === 3) {
       const nums = spaced.map(Number)
-      if (nums.every((n) => !isNaN(n))) return nums as Vec3
+      if (nums.every((num) => !isNaN(num))) return nums as Vec3
     }
     // Fall back to compact single-digit format: "001", "-101"
     const compact = input.replace(/\s+/g, ``)
@@ -25,8 +25,8 @@
     return null
   }
 
-  function handle_input(event: Event) {
-    const parsed = parse_hkl((event.target as HTMLInputElement).value)
+  function oninput(event: Event & { currentTarget: HTMLInputElement }) {
+    const parsed = parse_hkl(event.currentTarget.value)
     if (parsed) value = parsed
   }
 </script>
@@ -36,7 +36,7 @@
   <input
     type="text"
     value={hkl_text}
-    oninput={handle_input}
+    {oninput}
     placeholder="001"
     maxlength="12"
     title="Miller indices (e.g. 001, -101, or 10 0 1)"

package/dist/api/optimade.js

@@ -102,10 +102,10 @@ export const decode_structure_id = (encoded_id) => decodeURIComponent(encoded_id
 export function detect_provider_from_slug(slug, providers) {
     const decoded_slug = decode_structure_id(slug);
     const prefix = decoded_slug.split(`-`)[0].toLowerCase();
-    return providers.find((p) => p.id === prefix)?.id ?? ``;
+    return providers.find((provider) => provider.id === prefix)?.id ?? ``;
 }
 export async function fetch_optimade_structure(structure_id, provider, providers) {
-    const provider_config = providers.find((p) => p.id === provider);
+    const provider_config = providers.find((entry) => entry.id === provider);
     if (!provider_config)
         throw new Error(`Unknown provider: ${provider}`);
     const base_url = await resolve_provider_url(provider_config.attributes.base_url);
@@ -118,7 +118,7 @@ export async function fetch_optimade_structure(structure_id, provider, providers
     return Array.isArray(data.data) ? data.data[0] : data.data;
 }
 export async function fetch_suggested_structures(provider, providers, limit = 12) {
-    const provider_config = providers.find((p) => p.id === provider);
+    const provider_config = providers.find((entry) => entry.id === provider);
     if (!provider_config)
         throw new Error(`Unknown provider: ${provider}`);
     try {

package/dist/brillouin/BrillouinZone.svelte

@@ -293,8 +293,11 @@
   })
 
   function onkeydown(event: KeyboardEvent) {
-    const target = event.target as HTMLElement
-    if (target.tagName === `INPUT` || target.tagName === `TEXTAREA`) return
+    const target = event.target
+    if (
+      target instanceof HTMLElement &&
+      (target.tagName === `INPUT` || target.tagName === `TEXTAREA`)
+    ) return
 
     if (event.key === `f` && fullscreen_toggle) toggle_fullscreen(wrapper)
     else if (event.key === `i`) info_pane_open = !info_pane_open

package/dist/brillouin/BrillouinZone.svelte.d.ts

@@ -78,6 +78,6 @@ type $$ComponentProps = {
     on_fullscreen_change?: (data: BZHandlerData) => void;
     on_hover?: (data: BZHoverData | null) => void;
 } & HTMLAttributes<HTMLDivElement>;
-declare const BrillouinZone: import("svelte").Component<$$ComponentProps, {}, "structure" | "height" | "width" | "dragover" | "fullscreen" | "hovered" | "controls_open" | "loading" | "camera_projection" | "vector_scale" | "info_pane_open" | "wrapper" | "png_dpi" | "error_msg" | "bz_order" | "surface_color" | "surface_opacity" | "edge_color" | "edge_width" | "show_vectors" | "show_ibz" | "ibz_color" | "ibz_opacity" | "bz_data" | "ibz_data">;
+declare const BrillouinZone: import("svelte").Component<$$ComponentProps, {}, "structure" | "height" | "width" | "dragover" | "loading" | "fullscreen" | "hovered" | "controls_open" | "camera_projection" | "vector_scale" | "info_pane_open" | "wrapper" | "png_dpi" | "error_msg" | "bz_order" | "surface_color" | "surface_opacity" | "edge_color" | "edge_width" | "show_vectors" | "show_ibz" | "ibz_color" | "ibz_opacity" | "bz_data" | "ibz_data">;
 type BrillouinZone = ReturnType<typeof BrillouinZone>;
 export default BrillouinZone;

package/dist/brillouin/BrillouinZoneExportPane.svelte

@@ -102,9 +102,7 @@
   </label>
 
   <h4 id="export-as-data"
-    {@attach tooltip({
-      content: `Includes vertices, faces, edges, and reciprocal lattice vectors`,
-    })}
+    {@attach tooltip({ content: `Includes vertices, faces, edges, and reciprocal lattice vectors` })}
   >
     Export as data
   </h4>

package/dist/brillouin/BrillouinZoneInfoPane.svelte

@@ -94,7 +94,7 @@
     // Reciprocal Lattice section
     const k_lattice_items: InfoItem[] = bz_data.k_lattice.map((vec, idx) => ({
       label: [`b₁`, `b₂`, `b₃`][idx],
-      value: `(${vec.map((x) => format_num(x, `.3~f`)).join(`, `)})`,
+      value: `(${vec.map((coord) => format_num(coord, `.3~f`)).join(`, `)})`,
       key: `reciprocal-${[`b1`, `b2`, `b3`][idx]}`,
     }))
 

package/dist/brillouin/BrillouinZoneScene.svelte

@@ -118,7 +118,7 @@
   })
 
   const computed_camera_position = $derived.by(() =>
-    camera_position || ([10, 3, 8].map((x) => x * Math.max(1, bz_size)) as Vec3)
+    camera_position || ([10, 3, 8].map((coord) => coord * Math.max(1, bz_size)) as Vec3)
   )
 
   const gizmo_props = $derived({
@@ -189,7 +189,7 @@
         const e2: Vec3 = math.subtract(v2, v0)
         const normal_vec = math.cross_3d(e1, e2)
         const len = Math.hypot(...normal_vec)
-        const norm = len > 1e-10 ? normal_vec.map((x) => x / len) : [0, 0, 0]
+        const norm = len > 1e-10 ? normal_vec.map((coord) => coord / len) : [0, 0, 0]
         normals.push(...norm, ...norm, ...norm)
       }
     }
@@ -388,8 +388,8 @@
     <!-- Reciprocal lattice vectors -->
     {#if show_vectors && bz_data.k_lattice}
       {#each bz_data.k_lattice as vec, idx (idx)}
-        {@const scaled_vec = vec.map((x) => x * vector_scale) as Vec3}
-        {@const label_position = scaled_vec.map((x) => x * 1.15) as Vec3}
+        {@const scaled_vec = vec.map((coord) => coord * vector_scale) as Vec3}
+        {@const label_position = scaled_vec.map((coord) => coord * 1.15) as Vec3}
         <Arrow
           position={[0, 0, 0]}
           vector={scaled_vec}
@@ -443,7 +443,7 @@
     {#if k_path_labels}
       {#each k_path_labels as { position, label }, idx (`${label}-${idx}`)}
         {#if label}
-          <extras.HTML center position={position.map((x) => x * 1.1) as Vec3}>
+          <extras.HTML center position={position.map((coord) => coord * 1.1) as Vec3}>
             <span
               style="background: rgba(0, 0, 0, 0.3); padding: 0 3px; border-radius: 2px; color: white"
             >

package/dist/brillouin/compute.js

@@ -8,9 +8,7 @@ const normalize = (vec) => {
     return mag < 1e-10 ? [0, 0, 0] : [vec[0] / mag, vec[1] / mag, vec[2] / mag];
 };
 // Check if rotation matrix is identity
-function is_identity_rotation(rot) {
-    return rot.every((row, idx) => row.every((val, jdx) => Math.abs(val - (idx === jdx ? 1 : 0)) < TOL));
-}
+const is_identity_rotation = (rot) => rot.every((row, idx) => row.every((val, jdx) => Math.abs(val - (idx === jdx ? 1 : 0)) < TOL));
 // Extract unique point group rotation matrices from space group operations.
 // Returns fractional-coordinate rotations (W matrices from spglib convention).
 // These must be converted to Cartesian k-space before use in clipping.
@@ -149,12 +147,12 @@ max_planes_by_order = { 1: 26, 2: 80, 3: 150 }) {
         const dist_sq = pt[0] ** 2 + pt[1] ** 2 + pt[2] ** 2;
         return { normal: normalize(pt), dist: Math.sqrt(dist_sq) / 2, dist_sq };
     })
-        .filter((p) => p !== null)
+        .filter((plane) => plane !== null)
         .sort((a, b) => a.dist_sq - b.dist_sq)
         .slice(0, max_planes);
     // Pre-compute plane data for fast access
-    const normals = planes.map((p) => p.normal);
-    const distances = planes.map((p) => p.dist);
+    const normals = planes.map((plane) => plane.normal);
+    const distances = planes.map((plane) => plane.dist);
     const dedup = new VertexDeduplicator(TOL * 10);
     const vertices = [];
     // Test all three-plane intersections
@@ -203,7 +201,7 @@ export function compute_convex_hull(vertices, edge_sharp_angle_deg = 5) {
     if (vertices.length < 4) {
         throw new Error(`Need ≥4 vertices for convex hull, got ${vertices.length}`);
     }
-    const geometry = new ConvexGeometry(vertices.map((cert) => new Vector3(...cert)));
+    const geometry = new ConvexGeometry(vertices.map((vertex) => new Vector3(...vertex)));
     const pos = geometry.getAttribute(`position`);
     const geometry_index = geometry.index;
     // Deduplicate vertices from Three.js geometry
@@ -211,9 +209,9 @@ export function compute_convex_hull(vertices, edge_sharp_angle_deg = 5) {
     const vert_map = new Map();
     for (let idx_vertex = 0; idx_vertex < pos.count; idx_vertex++) {
         const vert = [pos.getX(idx_vertex), pos.getY(idx_vertex), pos.getZ(idx_vertex)];
-        const existing_idx = unique_verts.findIndex((u) => Math.abs(u[0] - vert[0]) < TOL &&
-            Math.abs(u[1] - vert[1]) < TOL &&
-            Math.abs(u[2] - vert[2]) < TOL);
+        const existing_idx = unique_verts.findIndex((unique_vert) => Math.abs(unique_vert[0] - vert[0]) < TOL &&
+            Math.abs(unique_vert[1] - vert[1]) < TOL &&
+            Math.abs(unique_vert[2] - vert[2]) < TOL);
         vert_map.set(idx_vertex, existing_idx === -1 ? unique_verts.push(vert) - 1 : existing_idx);
     }
     // Build faces with deduplicated vertex indices
@@ -227,23 +225,25 @@ export function compute_convex_hull(vertices, edge_sharp_angle_deg = 5) {
                 geometry_index.getX(idx_face * 3 + 2),
             ]
             : [idx_face * 3, idx_face * 3 + 1, idx_face * 3 + 2];
-        faces.push(tri.map((j) => {
-            const mapped = vert_map.get(j);
+        faces.push(tri.map((vertex_idx) => {
+            const mapped = vert_map.get(vertex_idx);
             if (mapped === undefined)
-                throw new Error(`Vertex ${j} not mapped`);
+                throw new Error(`Vertex ${vertex_idx} not mapped`);
             return mapped;
         }));
     }
     // Compute face normals and build edge-to-face adjacency
     const face_normals = faces.map((face) => {
-        const [v0, v1, v2] = face.slice(0, 3).map((vi) => unique_verts[vi]);
+        const [v0, v1, v2] = face.slice(0, 3).map((vertex_idx) => unique_verts[vertex_idx]);
         return normalize(math.cross_3d(math.subtract(v1, v0), math.subtract(v2, v0)));
     });
     const edge_to_faces = new Map();
     faces.forEach((face, face_idx) => {
-        face.forEach((v1, idx) => {
-            const v2 = face[(idx + 1) % face.length];
-            const key = v1 < v2 ? `${v1},${v2}` : `${v2},${v1}`;
+        face.forEach((from_vertex_idx, idx) => {
+            const to_vertex_idx = face[(idx + 1) % face.length];
+            const key = from_vertex_idx < to_vertex_idx
+                ? `${from_vertex_idx},${to_vertex_idx}`
+                : `${to_vertex_idx},${from_vertex_idx}`;
             const adj = edge_to_faces.get(key);
             if (adj)
                 adj.push(face_idx);
@@ -322,14 +322,14 @@ export function compute_ibz_clipping_planes(point_group_ops) {
     return planes;
 }
 // Flip a clipping plane to the opposite half-space
-const flip_plane = (p) => ({
-    normal: math.scale(p.normal, -1),
-    dist: -p.dist,
+const flip_plane = (plane) => ({
+    normal: math.scale(plane.normal, -1),
+    dist: -plane.dist,
 });
 // Clip polyhedron vertices by a half-space, adding intersection points where edges cross
 function clip_polyhedron_by_plane(vertices, faces, plane) {
     const { normal, dist } = plane;
-    const signed_dists = vertices.map((v) => math.dot(v, normal) - dist);
+    const signed_dists = vertices.map((vertex) => math.dot(vertex, normal) - dist);
     // Keep vertices inside the half-space
     const result = vertices.filter((_, idx) => signed_dists[idx] <= TOL);
     // Build edge set from faces

package/dist/brillouin/index.d.ts

@@ -5,4 +5,4 @@ export { default as BrillouinZoneInfoPane } from './BrillouinZoneInfoPane.svelte
 export { default as BrillouinZoneScene } from './BrillouinZoneScene.svelte';
 export { default as BrillouinZoneTooltip } from './BrillouinZoneTooltip.svelte';
 export * from './compute';
-export * from './types';
+export type * from './types';

package/dist/brillouin/index.js

@@ -5,4 +5,3 @@ export { default as BrillouinZoneInfoPane } from './BrillouinZoneInfoPane.svelte
 export { default as BrillouinZoneScene } from './BrillouinZoneScene.svelte';
 export { default as BrillouinZoneTooltip } from './BrillouinZoneTooltip.svelte';
 export * from './compute';
-export * from './types';

package/dist/brillouin/types.d.ts

@@ -1,13 +1,10 @@
-import type { Matrix3x3, Vec3 } from '../math';
+import type { Matrix3x3, Point2D, Vec3 } from '../math';
 import type { Crystal } from '../structure';
 import type { TooltipConfig, TooltipProp } from '../tooltip';
 export type BZHoverData = {
     position_cartesian: Vec3;
     position_fractional: Vec3 | null;
-    screen_position: {
-        x: number;
-        y: number;
-    };
+    screen_position: Point2D;
     is_ibz: boolean;
     bz_order: number;
     bz_volume: number;
@@ -18,17 +15,16 @@ export type BZTooltipConfig = TooltipConfig<BZHoverData>;
 export type BZTooltipProp = TooltipProp<BZHoverData, [{
     hover_data: BZHoverData;
 }]>;
-export type IrreducibleBZData = {
+type BZMeshData = {
     vertices: Vec3[];
     faces: number[][];
     edges: Vec3[][];
+};
+export type IrreducibleBZData = BZMeshData & {
     volume: number;
 };
-export type BrillouinZoneData = {
+export type BrillouinZoneData = BZMeshData & {
     order: number;
-    vertices: Vec3[];
-    faces: number[][];
-    edges: Vec3[][];
     k_lattice: Matrix3x3;
     volume: number;
 };
@@ -41,8 +37,7 @@ export type BrillouinZoneProps = {
     edge_width?: number;
     show_vectors?: boolean;
 };
-export type ConvexHullData = {
-    vertices: Vec3[];
-    faces: number[][];
+export type ConvexHullData = Pick<BZMeshData, `vertices` | `faces`> & {
     edges: [number, number][];
 };
+export {};

package/dist/chempot-diagram/ChemPotDiagram.svelte

@@ -233,9 +233,9 @@ const is_hover_info_3d = (value: ChemPotHoverInfo | null): value is ChemPotHover
             <h5 id="neighbors">Neighbors ({hover_info.neighbors.length})</h5>
             <p>
               {
-                hover_info.neighbors.map((f) => get_electro_neg_formula(f, true, ``, `.3~s`)).join(
-                  `, `,
-                )
+                hover_info.neighbors.map((formula) =>
+                  get_electro_neg_formula(formula, true, ``, `.3~s`)
+                ).join(`, `)
               }
             </p>
           {/if}

package/dist/chempot-diagram/ChemPotDiagram2D.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import { type D3InterpolateName } from '../colors'
+  import type { D3InterpolateName } from '../colors'
   import { get_electro_neg_formula } from '../composition/format'
   import { extract_formula_elements } from '../composition/parse'
   import TemperatureSlider from '../convex-hull/TemperatureSlider.svelte'
@@ -433,9 +433,8 @@
   let copy_status = $state(false)
   let copy_timeout_id: ReturnType<typeof setTimeout> | null = null
 
-  function get_svg_element(): SVGSVGElement | null {
-    return scatter_wrapper?.querySelector<SVGSVGElement>(`svg`) ?? null
-  }
+  const get_svg_element = (): SVGSVGElement | null =>
+    scatter_wrapper?.querySelector<SVGSVGElement>(`svg`) ?? null
 
   function get_json_string(): string {
     return JSON.stringify(

package/dist/chempot-diagram/ChemPotDiagram3D.svelte

@@ -1,10 +1,7 @@
 <script lang="ts">
-  import { type D3InterpolateName } from '../colors'
-  import {
-    get_electro_neg_formula,
-    get_formula_label_segments,
-    type FormulaLabelSegment,
-  } from '../composition/format'
+  import type { D3InterpolateName } from '../colors'
+  import { get_electro_neg_formula, get_formula_label_segments } from '../composition/format'
+  import type { FormulaLabelSegment } from '../composition/format'
   import { extract_formula_elements } from '../composition/parse'
   import TemperatureSlider from '../convex-hull/TemperatureSlider.svelte'
   import type { PhaseData } from '../convex-hull/types'
@@ -74,6 +71,9 @@
   } from './types'
   import { CHEMPOT_DEFAULTS } from './types'
 
+  const edge_key = (key_a: string, key_b: string): string =>
+    key_a < key_b ? `${key_a}|${key_b}` : `${key_b}|${key_a}`
+
   let {
     entries = [],
     config = {},
@@ -153,9 +153,8 @@
       : CHEMPOT_DEFAULTS.formula_colors,
   )
 
-  function formula_label_segments(formula: string): FormulaLabelSegment[] {
-    return get_formula_label_segments(get_electro_neg_formula(formula, true, ``, `.3~s`))
-  }
+  const formula_label_segments = (formula: string): FormulaLabelSegment[] =>
+    get_formula_label_segments(get_electro_neg_formula(formula, true, ``, `.3~s`))
 
   function normalize_projection_triplet(
     maybe_triplet: string[] | undefined,
@@ -421,7 +420,11 @@
         label_font_size: bbox_diagonal(padded),
       })
     }
-    const fonts = scale_to_font_range(result.map((d) => d.label_font_size), 9, 15)
+    const fonts = scale_to_font_range(
+      result.map((render_domain) => render_domain.label_font_size),
+      9,
+      15,
+    )
     for (let idx = 0; idx < result.length; idx++) result[idx].label_font_size = fonts[idx]
     return result
   })
@@ -792,8 +795,8 @@
       // Compute edges in swizzled (Three.js) coords since ConvexGeometry works there
       const swizzled = domain.points_3d.map((point) => to_render_xyz(point))
       for (const [pa, pb] of get_domain_edges(swizzled)) {
-        const ka = pa.map((v) => v.toFixed(4)).join(`,`)
-        const kb = pb.map((v) => v.toFixed(4)).join(`,`)
+        const ka = pa.map((coord) => coord.toFixed(4)).join(`,`)
+        const kb = pb.map((coord) => coord.toFixed(4)).join(`,`)
         const key = ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`
         if (seen.has(key)) continue
         seen.add(key)
@@ -893,17 +896,17 @@
 
     // Domain vertex centroids in render coords (swizzled + axis stretch), matching hull_base_geometry.
     const centroids = render_domains
-      .filter((d) => !d.is_draw_formula && d.points_3d.length > 0)
-      .map((d) => {
+      .filter((domain) => !domain.is_draw_formula && domain.points_3d.length > 0)
+      .map((domain) => {
         let sx = 0, sy = 0, sz = 0
-        for (const pt of d.points_3d) {
+        for (const pt of domain.points_3d) {
           const [x_val, y_val, z_val] = to_render_xyz(pt)
           sx += x_val
           sy += y_val
           sz += z_val
         }
-        const n = d.points_3d.length
-        return { formula: d.formula, cx: sx / n, cy: sy / n, cz: sz / n }
+        const n_points = domain.points_3d.length
+        return { formula: domain.formula, cx: sx / n_points, cy: sy / n_points, cz: sz / n_points }
       })
 
     // Assign each face to the nearest domain centroid
@@ -936,8 +939,6 @@
         `${round(pos.getX(vert_idx))},${round(pos.getY(vert_idx))},${
           round(pos.getZ(vert_idx))
         }`
-      const ekey = (ka: string, kb: string): string =>
-        ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`
       // Compute face normals
       const normals: Vec3[] = []
       for (let face_idx = 0; face_idx < n_faces; face_idx++) {
@@ -961,9 +962,9 @@
         const keys = [vkey(base), vkey(base + 1), vkey(base + 2)]
         for (
           const ek of [
-            ekey(keys[0], keys[1]),
-            ekey(keys[1], keys[2]),
-            ekey(keys[0], keys[2]),
+            edge_key(keys[0], keys[1]),
+            edge_key(keys[1], keys[2]),
+            edge_key(keys[0], keys[2]),
           ]
         ) {
           const list = edge_faces.get(ek)
@@ -1132,9 +1133,8 @@
   })
 
   // Deduplicate 3D points within tolerance (reuses compute.ts dedup_points)
-  function dedup_3d(pts: number[][], tol: number = 1e-4): number[][] {
-    return dedup_points(pts, tol).unique
-  }
+  const dedup_3d = (pts: number[][], tol: number = 1e-4): number[][] =>
+    dedup_points(pts, tol).unique
 
   const controls_series = $derived<DataSeries3D[]>([
     {
@@ -1243,7 +1243,7 @@
     if (unique_points.length === 3) {
       const geom = new THREE.BufferGeometry()
       const vectors = unique_points.map((pt) => to_vec3(pt))
-      const verts = new Float32Array(vectors.flatMap((v) => [v.x, v.y, v.z]))
+      const verts = new Float32Array(vectors.flatMap((vec) => [vec.x, vec.y, vec.z]))
       geom.setAttribute(`position`, new THREE.Float32BufferAttribute(verts, 3))
       geom.setIndex([0, 1, 2, 2, 1, 0]) // both winding orders for double-sided pick
       geom.computeVertexNormals()
@@ -1387,7 +1387,7 @@
 
   // Bounding box of all data points in DATA coordinates (before swizzle)
   const raw_data_bbox = $derived.by(() => {
-    const pts = render_domains.flatMap((d) => d.points_3d)
+    const pts = render_domains.flatMap((domain) => domain.points_3d)
     if (pts.length === 0) return { mins: [0, 0, 0], maxs: [1, 1, 1] }
     const mins = [Infinity, Infinity, Infinity]
     const maxs = [-Infinity, -Infinity, -Infinity]
@@ -1486,11 +1486,10 @@
   // Place axis label just past the outer end of the axis (the end closer to 0).
   // In isometric 3D, the end near 0 projects outward at the front edge of the
   // bounding box, while the negative end projects inward toward the center.
-  function outer_end(range: [number, number]): number {
-    return Math.abs(range[0]) <= Math.abs(range[1]) ? range[0] : range[1]
-  }
+  const outer_end = (range: [number, number]): number =>
+    Math.abs(range[0]) <= Math.abs(range[1]) ? range[0] : range[1]
   // Direction from range center toward outer end (to extend the label beyond the grid)
-  function outer_dir(range: [number, number]): number {
+  const outer_direction = (range: [number, number]): number => {
     const end = outer_end(range)
     const mid = (range[0] + range[1]) / 2
     return end >= mid ? 1 : -1
@@ -1524,7 +1523,7 @@
         line_geom = make_line_geom(ls, le)
         // Axis label past the outer end of the axis (near 0, projects outward)
         label_pos = swiz(
-          outer_end(r0) + outer_dir(r0) * axis_label_dist,
+          outer_end(r0) + outer_direction(r0) * axis_label_dist,
           back[1] + out_x * tick_label_dist * 0.5,
           back[2] + out_y * tick_label_dist,
         )
@@ -1555,7 +1554,7 @@
         line_geom = make_line_geom(ls, le)
         label_pos = swiz(
           back[0],
-          outer_end(r1) + outer_dir(r1) * axis_label_dist,
+          outer_end(r1) + outer_direction(r1) * axis_label_dist,
           back[2] + out_y * tick_label_dist,
         )
         for (const val of ticks) {
@@ -1582,7 +1581,7 @@
         label_pos = swiz(
           back[0],
           back[1] + out_x * tick_label_dist,
-          outer_end(r2) + outer_dir(r2) * axis_label_dist,
+          outer_end(r2) + outer_direction(r2) * axis_label_dist,
         )
         for (const val of ticks) {
           tick_geoms.push(make_line_geom(

package/dist/chempot-diagram/compute.js

@@ -12,7 +12,6 @@ const get_reduced_formula = (composition) => {
     const amounts = Object.values(composition).filter((amt) => amt > 0);
     if (amounts.length === 0)
         return {};
-    // For fractional amounts, find smallest multiplier (1–100) that yields near-integer ratios
     let scale = 1;
     if (!amounts.every((amt) => Number.isInteger(amt))) {
         scale = 0;
@@ -371,12 +370,7 @@ export function compute_domains(hyperplanes, border_hyperplanes, hyperplane_entr
         if (!advance_combo())
             break;
     }
-    // Remove empty domains
-    for (const key of Object.keys(domains)) {
-        if (domains[key].length === 0)
-            delete domains[key];
-    }
-    return domains;
+    return Object.fromEntries(Object.entries(domains).filter(([, domain]) => domain.length > 0));
 }
 // Apply element padding: replace coordinates close to default_min_limit with
 // actual_min - padding for cleaner visual bounds. Single pass over all points.

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

@@ -9,7 +9,7 @@ export interface TempFilterPayload {
     available_temperatures: number[];
     temp_filtered_entries: PhaseData[];
 }
-export declare function get_projection_source_entries(entries: PhaseData[], temp_filtered_entries: PhaseData[]): PhaseData[];
+export declare const get_projection_source_entries: (entries: PhaseData[], temp_filtered_entries: PhaseData[]) => PhaseData[];
 export declare function get_temp_filter_payload(entries: PhaseData[], temperature: number | undefined, config: ChemPotDiagramConfig, props: TempFilterProps): TempFilterPayload;
 export declare function get_valid_temperature(temperature: number | undefined, has_temp_data: boolean, available_temperatures: number[]): number | undefined;
 export {};

package/dist/chempot-diagram/temperature.js

@@ -1,8 +1,6 @@
 import { analyze_temperature_data, filter_entries_at_temperature, } from '../convex-hull/helpers';
 import { CHEMPOT_DEFAULTS } from './types';
-export function get_projection_source_entries(entries, temp_filtered_entries) {
-    return temp_filtered_entries.length > 0 ? temp_filtered_entries : entries;
-}
+export const get_projection_source_entries = (entries, temp_filtered_entries) => (temp_filtered_entries.length > 0 ? temp_filtered_entries : entries);
 const resolve_temp_filter_options = (config, props) => ({
     interpolate: config.interpolate_temperature ??
         props.interpolate_temperature ??

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

@@ -1,5 +1,6 @@
 import type { D3InterpolateName } from '../colors';
 import type { PhaseData } from '../convex-hull/types';
+import type { Point2D } from '../math';
 export type ChemPotLimits = Partial<Record<string, [number, number]>>;
 export type ChemPotColorMode = `none` | `energy` | `formation_energy` | `arity` | `entries`;
 export type ChemPotProjectionMode = `single` | `grid`;
@@ -32,14 +33,12 @@ export interface ChemPotDiagramData {
     hyperplane_entries: PhaseData[];
     lims: [number, number][];
 }
-export interface ChemPotHoverPointer {
-    x: number;
-    y: number;
-}
 export interface ChemPotHoverInfoBase {
     formula: string;
     view: `2d` | `3d`;
-    pointer?: ChemPotHoverPointer;
+    pointer?: Point2D;
+    n_points: number;
+    axis_ranges: AxisRangeData[];
 }
 export interface AxisRangeData {
     element: string;
@@ -48,16 +47,12 @@ export interface AxisRangeData {
 }
 export interface ChemPotHoverInfo2D extends ChemPotHoverInfoBase {
     view: `2d`;
-    n_points: number;
-    axis_ranges: AxisRangeData[];
 }
 export interface ChemPotHoverInfo3D extends ChemPotHoverInfoBase {
     view: `3d`;
     n_vertices: number;
     n_edges: number;
-    n_points: number;
     ann_loc: number[];
-    axis_ranges: AxisRangeData[];
     touches_limits: string[];
     is_elemental: boolean;
     is_draw_formula: boolean;

package/dist/colors/index.js

@@ -103,6 +103,7 @@ export function pick_contrast_color(options = {}) {
 export const contrast_color = (options = {}) => (node) => {
     node.style.color = pick_contrast_color({ ...options, bg_color: get_bg_color(node) });
 };
+const is_valid_bg = (bg) => bg !== `` && bg !== `rgba(0, 0, 0, 0)` && bg !== `transparent`;
 // Detect and return the page background color from html/body elements or user preferences
 export function get_page_background(fallback_dark = `#1a1a1a`, fallback_light = `#ffffff`) {
     if (typeof window === `undefined`)
@@ -111,7 +112,6 @@ export function get_page_background(fallback_dark = `#1a1a1a`, fallback_light =
     const html_bg = getComputedStyle(document.documentElement).backgroundColor;
     const body_bg = getComputedStyle(document.body).backgroundColor;
     // Check if background is not transparent/unset
-    const is_valid_bg = (bg) => bg && bg !== `rgba(0, 0, 0, 0)` && bg !== `transparent`;
     // Prefer body background as it's more likely to be styled by the theme
     if (is_valid_bg(body_bg))
         return body_bg;
@@ -186,10 +186,10 @@ export function add_alpha(color, alpha) {
             return color;
         // Extract RGB, ignoring any existing alpha channel
         const is_short = hex.length === 3 || hex.length === 4;
-        const r = parseInt(is_short ? hex[0] + hex[0] : hex.slice(0, 2), 16);
-        const g = parseInt(is_short ? hex[1] + hex[1] : hex.slice(2, 4), 16);
-        const b = parseInt(is_short ? hex[2] + hex[2] : hex.slice(4, 6), 16);
-        return `rgba(${r}, ${g}, ${b}, ${clamped_alpha})`;
+        const red = parseInt(is_short ? hex[0] + hex[0] : hex.slice(0, 2), 16);
+        const green = parseInt(is_short ? hex[1] + hex[1] : hex.slice(2, 4), 16);
+        const blue = parseInt(is_short ? hex[2] + hex[2] : hex.slice(4, 6), 16);
+        return `rgba(${red}, ${green}, ${blue}, ${clamped_alpha})`;
     }
     // Handle rgb() colors
     if (color.startsWith(`rgb(`)) {

package/dist/composition/Composition.svelte

@@ -135,7 +135,8 @@
   onkeydown={(event: KeyboardEvent) => {
     if ([`Enter`, ` `].includes(event.key)) {
       event.preventDefault()
-      const target = event.currentTarget as Element
+      const target = event.currentTarget
+      if (!(target instanceof Element)) return
       const rect = target.getBoundingClientRect()
       context_menu.x = window.scrollX + rect.left + rect.width / 2
       context_menu.y = window.scrollY + rect.top + rect.height / 2