matterviz 0.3.7 → 0.4.1

package/dist/plot/{ReferenceLine3D.svelte → core/components/ReferenceLine3D.svelte}

@@ -1,19 +1,19 @@
 <script lang="ts">
   // ReferenceLine3D: 3D reference lines for axis-parallel, segments, and extended lines
   // Uses Line2 for proper variable-width lines (WebGL ignores linewidth on basic lines)
-  import type { Point3D, Vec3 } from '../math'
+  import type { Point3D, Vec2, Vec3 } from '../../../math'
   import { T, useThrelte } from '@threlte/core'
   import * as THREE from 'three'
   import { Line2 } from 'three/examples/jsm/lines/Line2.js'
   import { LineGeometry } from 'three/examples/jsm/lines/LineGeometry.js'
   import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js'
-  import { create_to_threejs, span_or } from './reference-line'
-  import type { RefLine3D } from './types'
+  import { create_to_threejs, span_or } from '../reference-line'
+  import type { RefLine3D } from '../types'
 
   let { ref_line, scene_size = [10, 10, 5], ranges }: {
     ref_line: RefLine3D
     scene_size?: Vec3
-    ranges: { x: [number, number]; y: [number, number]; z: [number, number] }
+    ranges: { x: Vec2; y: Vec2; z: Vec2 }
   } = $props()
 
   const { size } = useThrelte()
@@ -102,7 +102,7 @@
     color: ref_line.style?.color ?? `white`,
     opacity: ref_line.style?.opacity ?? 1,
     width: ref_line.style?.width ?? 2,
-    dashed: !!ref_line.style?.dash,
+    dashed: Boolean(ref_line.style?.dash),
   })
 
   // Create Line2 with LineGeometry and LineMaterial for proper variable-width lines

package/dist/plot/{ReferenceLine3D.svelte.d.ts → core/components/ReferenceLine3D.svelte.d.ts}

@@ -1,12 +1,12 @@
-import type { Vec3 } from '../math';
-import type { RefLine3D } from './types';
+import type { Vec2, Vec3 } from '../../../math';
+import type { RefLine3D } from '../types';
 type $$ComponentProps = {
     ref_line: RefLine3D;
     scene_size?: Vec3;
     ranges: {
-        x: [number, number];
-        y: [number, number];
-        z: [number, number];
+        x: Vec2;
+        y: Vec2;
+        z: Vec2;
     };
 };
 declare const ReferenceLine3D: import("svelte").Component<$$ComponentProps, {}, "">;

package/dist/plot/{ReferencePlane.svelte → core/components/ReferencePlane.svelte}

@@ -1,16 +1,16 @@
 <script lang="ts">
   // ReferencePlane: 3D reference planes (axis-aligned, normal-defined, or point-defined)
-  import type { Vec3 } from '../math'
-  import { cross_3d, normalize_vec3 } from '../math'
+  import type { Vec2, Vec3 } from '../../../math'
+  import { cross_3d, normalize_vec } from '../../../math'
   import { T } from '@threlte/core'
   import * as THREE from 'three'
-  import { create_to_threejs, span_or } from './reference-line'
-  import type { RefPlane } from './types'
+  import { create_to_threejs, span_or } from '../reference-line'
+  import type { RefPlane } from '../types'
 
   let { ref_plane, scene_size = [10, 10, 5], ranges }: {
     ref_plane: RefPlane
     scene_size?: Vec3
-    ranges: { x: [number, number]; y: [number, number]; z: [number, number] }
+    ranges: { x: Vec2; y: Vec2; z: Vec2 }
   } = $props()
 
   let [scene_x, scene_y, scene_z] = $derived(scene_size)
@@ -82,7 +82,7 @@
       const v2: Vec3 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]]
       const cross = cross_3d(v1, v2)
       if (Math.hypot(...cross) < 1e-9) return null // collinear points
-      return create_plane_from_normal(normalize_vec3(cross), p1)
+      return create_plane_from_normal(normalize_vec(cross), p1)
     }
     return null
   }
@@ -111,9 +111,9 @@
 
   // Create plane from normal and point, scaled to cover bounding box
   function create_plane_from_normal(normal: Vec3, point: Vec3): THREE.BufferGeometry {
-    const normalized = normalize_vec3(normal)
+    const normalized = normalize_vec(normal)
     // Pick u perpendicular to normal (use axis least aligned with normal)
-    const u_dir = normalize_vec3(
+    const u_dir = normalize_vec(
       cross_3d(normalized, Math.abs(normalized[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]),
     )
     const v_dir = cross_3d(normalized, u_dir)

package/dist/plot/{ReferencePlane.svelte.d.ts → core/components/ReferencePlane.svelte.d.ts}

@@ -1,12 +1,12 @@
-import type { Vec3 } from '../math';
-import type { RefPlane } from './types';
+import type { Vec2, Vec3 } from '../../../math';
+import type { RefPlane } from '../types';
 type $$ComponentProps = {
     ref_plane: RefPlane;
     scene_size?: Vec3;
     ranges: {
-        x: [number, number];
-        y: [number, number];
-        z: [number, number];
+        x: Vec2;
+        y: Vec2;
+        z: Vec2;
     };
 };
 declare const ReferencePlane: import("svelte").Component<$$ComponentProps, {}, "">;

package/dist/plot/{ZeroLines.svelte → core/components/ZeroLines.svelte}

@@ -1,7 +1,7 @@
 <script lang="ts">
-  import type { Vec2 } from '../math'
-  import type { Sides } from './layout'
-  import { get_scale_type_name, type ScaleType } from './'
+  import type { Vec2 } from '../../../math'
+  import type { Sides } from '../layout'
+  import { get_scale_type_name, type ScaleType } from '../..'
 
   let {
     display,

package/dist/plot/{ZeroLines.svelte.d.ts → core/components/ZeroLines.svelte.d.ts}

@@ -1,6 +1,6 @@
-import type { Vec2 } from '../math';
-import type { Sides } from './layout';
-import { type ScaleType } from './';
+import type { Vec2 } from '../../../math';
+import type { Sides } from '../layout';
+import { type ScaleType } from '../..';
 type $$ComponentProps = {
     display: {
         x_zero_line?: boolean;

package/dist/plot/{ZoomRect.svelte → core/components/ZoomRect.svelte}

@@ -1,5 +1,5 @@
 <script lang="ts">
-  import type { Point2D } from '../math'
+  import type { Point2D } from '../../../math'
 
   let { start, current }: { start: Point2D | null; current: Point2D | null } = $props()
 </script>

package/dist/plot/{ZoomRect.svelte.d.ts → core/components/ZoomRect.svelte.d.ts}

@@ -1,4 +1,4 @@
-import type { Point2D } from '../math';
+import type { Point2D } from '../../../math';
 type $$ComponentProps = {
     start: Point2D | null;
     current: Point2D | null;

package/dist/plot/core/components/index.d.ts

@@ -0,0 +1,17 @@
+export { default as AxisLabel } from './AxisLabel.svelte';
+export { default as ColorBar } from './ColorBar.svelte';
+export { default as ColorScaleSelect } from './ColorScaleSelect.svelte';
+export { default as ControlPane } from './ControlPane.svelte';
+export { default as FillArea } from './FillArea.svelte';
+export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
+export { default as Line } from './Line.svelte';
+export { default as PlotAxis } from './PlotAxis.svelte';
+export { default as PlotControls } from './PlotControls.svelte';
+export { default as PlotLegend } from './PlotLegend.svelte';
+export { default as PlotTooltip } from './PlotTooltip.svelte';
+export { default as PortalSelect } from './PortalSelect.svelte';
+export { default as ReferenceLine } from './ReferenceLine.svelte';
+export { default as ReferenceLine3D } from './ReferenceLine3D.svelte';
+export { default as ReferencePlane } from './ReferencePlane.svelte';
+export { default as ZeroLines } from './ZeroLines.svelte';
+export { default as ZoomRect } from './ZoomRect.svelte';

package/dist/plot/core/components/index.js

@@ -0,0 +1,17 @@
+export { default as AxisLabel } from './AxisLabel.svelte';
+export { default as ColorBar } from './ColorBar.svelte';
+export { default as ColorScaleSelect } from './ColorScaleSelect.svelte';
+export { default as ControlPane } from './ControlPane.svelte';
+export { default as FillArea } from './FillArea.svelte';
+export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
+export { default as Line } from './Line.svelte';
+export { default as PlotAxis } from './PlotAxis.svelte';
+export { default as PlotControls } from './PlotControls.svelte';
+export { default as PlotLegend } from './PlotLegend.svelte';
+export { default as PlotTooltip } from './PlotTooltip.svelte';
+export { default as PortalSelect } from './PortalSelect.svelte';
+export { default as ReferenceLine } from './ReferenceLine.svelte';
+export { default as ReferenceLine3D } from './ReferenceLine3D.svelte';
+export { default as ReferencePlane } from './ReferencePlane.svelte';
+export { default as ZeroLines } from './ZeroLines.svelte';
+export { default as ZoomRect } from './ZoomRect.svelte';

package/dist/plot/{data-cleaning.d.ts → core/data-cleaning.d.ts}

@@ -1,4 +1,74 @@
-import type { CleaningConfig, CleaningQuality, CleaningResult, DataSeries, InstabilityResult, InvalidValueMode, LocalOutlierConfig, LocalOutlierResult, PhysicalBounds } from './types';
+import type { Vec2 } from '../../math';
+import type { DataSeries } from './types';
+export interface OscillationWeights {
+    derivative_variance?: number;
+    amplitude_growth?: number;
+    sign_changes?: number;
+}
+export type InvalidValueMode = `remove` | `propagate` | `interpolate`;
+export type TruncationMode = `hard_cut` | `mark_unstable`;
+export interface PhysicalBounds {
+    min?: number | ((x: number) => number);
+    max?: number | ((x: number) => number);
+    mode?: `clamp` | `filter` | `null`;
+}
+export type SmoothingConfig = {
+    type: `moving_avg`;
+    window: number;
+} | {
+    type: `savgol`;
+    window: number;
+    polynomial_order?: number;
+} | {
+    type: `gaussian`;
+    sigma: number;
+};
+export interface LocalOutlierConfig {
+    window_half?: number;
+    mad_threshold?: number;
+    max_iterations?: number;
+}
+export interface LocalOutlierResult {
+    kept_indices: number[];
+    removed_indices: number[];
+    iterations_used: number;
+}
+export interface CleaningConfig {
+    oscillation_threshold?: number;
+    oscillation_weights?: OscillationWeights;
+    window_size?: number;
+    invalid_values?: InvalidValueMode;
+    bounds?: PhysicalBounds;
+    smooth?: SmoothingConfig;
+    local_outliers?: LocalOutlierConfig;
+    truncation_mode?: TruncationMode;
+    in_place?: boolean;
+}
+export interface CleaningQuality {
+    points_removed: number;
+    invalid_values_found: number;
+    oscillation_detected: boolean;
+    oscillation_score?: number;
+    bounds_violations: number;
+    outliers_removed?: number;
+    stable_range?: Vec2;
+    truncated_at_x?: number;
+}
+export interface CleaningResult<T = DataSeries> {
+    series: T;
+    quality: CleaningQuality;
+}
+export interface InstabilityResult {
+    detected: boolean;
+    onset_index: number;
+    onset_x: number;
+    combined_score: number;
+    method_scores: {
+        derivative_variance: number;
+        amplitude_growth: number;
+        sign_changes: number;
+    };
+}
 export declare function compute_local_variance(values: number[], window_size: number): number[];
 export declare function detect_instability(x_values: readonly number[], y_values: readonly number[], config?: Pick<CleaningConfig, `oscillation_weights` | `oscillation_threshold` | `window_size`>): InstabilityResult;
 export declare function smooth_moving_average(values: number[], window: number): number[];

package/dist/plot/{data-cleaning.js → core/data-cleaning.js}

@@ -1,6 +1,6 @@
 // Data cleaning utilities for plot data
 // Detects oscillations, enforces physical bounds, and handles multi-dimensional datasets
-import { apply_gaussian_smearing } from '../spectral/helpers';
+import { apply_gaussian_smearing } from '../../spectral/helpers';
 // Default configuration values
 const DEFAULT_WINDOW_SIZE = 5;
 const DEFAULT_OSCILLATION_THRESHOLD = 3.0;
@@ -243,7 +243,7 @@ function compute_savgol_coefficients(window, order) {
     for (let idx = -half; idx <= half; idx++) {
         const row = [];
         for (let power = 0; power <= order; power++) {
-            row.push(Math.pow(idx, power));
+            row.push(idx ** power);
         }
         vandermonde.push(row);
     }
@@ -274,7 +274,7 @@ export function smooth_savitzky_golay(values, window, polynomial_order = DEFAULT
     const half = Math.floor(actual_window / 2);
     const result = Array(values.length);
     // Cache coefficient sum to avoid O(n × window) redundant reductions in loop
-    const coeffs_sum = coeffs.reduce((a, b) => a + b, 0);
+    const coeffs_sum = coeffs.reduce((sum, coeff) => sum + coeff, 0);
     for (let idx = 0; idx < values.length; idx++) {
         let [sum, weight_sum] = [0, 0];
         for (let jdx = 0; jdx < actual_window; jdx++) {
@@ -437,8 +437,8 @@ export function handle_invalid_values(values, mode) {
             }
             if (left_idx >= 0 && right_idx < cleaned.length) {
                 // Linear interpolation
-                const t = (idx - left_idx) / (right_idx - left_idx);
-                cleaned[idx] = cleaned[left_idx] + t * (cleaned[right_idx] - cleaned[left_idx]);
+                const frac = (idx - left_idx) / (right_idx - left_idx);
+                cleaned[idx] = cleaned[left_idx] + frac * (cleaned[right_idx] - cleaned[left_idx]);
             }
             else if (left_idx >= 0) {
                 cleaned[idx] = cleaned[left_idx];
@@ -496,9 +496,7 @@ export function sync_metadata(metadata, kept_indices) {
     return kept_indices.map((idx) => metadata[idx]);
 }
 // Filter arrays by kept indices
-function filter_by_indices(arr, kept_indices) {
-    return kept_indices.map((idx) => arr[idx]);
-}
+const filter_by_indices = (arr, kept_indices) => kept_indices.map((idx) => arr[idx]);
 // Check if value is within bounds (static or x-dependent)
 function is_in_bounds(val, x_val, bounds) {
     const min = typeof bounds.min === `function` ? bounds.min(x_val) : bounds.min;
@@ -799,34 +797,34 @@ function transpose(matrix) {
     }
     return result;
 }
-function multiply_matrices(a, b) {
-    const rows_a = a.length;
-    const cols_a = a[0]?.length ?? 0;
-    const cols_b = b[0]?.length ?? 0;
+function multiply_matrices(matrix_a, matrix_b) {
+    const rows_a = matrix_a.length;
+    const cols_a = matrix_a[0]?.length ?? 0;
+    const cols_b = matrix_b[0]?.length ?? 0;
     const result = Array.from({ length: rows_a }, () => Array(cols_b).fill(0));
     for (let row = 0; row < rows_a; row++) {
         for (let col = 0; col < cols_b; col++) {
-            for (let k = 0; k < cols_a; k++) {
-                result[row][col] += a[row][k] * b[k][col];
+            for (let idx_k = 0; idx_k < cols_a; idx_k++) {
+                result[row][col] += matrix_a[row][idx_k] * matrix_b[idx_k][col];
             }
         }
     }
     return result;
 }
 function invert_matrix(matrix) {
-    const n = matrix.length;
-    if (n === 0 || matrix[0].length !== n)
+    const size = matrix.length;
+    if (size === 0 || matrix[0].length !== size)
         return null;
     // Create augmented matrix [A | I]
     const aug = matrix.map((row, idx) => [
         ...row,
-        ...Array.from({ length: n }, (_, jdx) => (idx === jdx ? 1 : 0)),
+        ...Array.from({ length: size }, (_, jdx) => (idx === jdx ? 1 : 0)),
     ]);
     // Gaussian elimination with partial pivoting
-    for (let col = 0; col < n; col++) {
+    for (let col = 0; col < size; col++) {
         // Find pivot
         let max_row = col;
-        for (let row = col + 1; row < n; row++) {
+        for (let row = col + 1; row < size; row++) {
             if (Math.abs(aug[row][col]) > Math.abs(aug[max_row][col])) {
                 max_row = row;
             }
@@ -838,18 +836,18 @@ function invert_matrix(matrix) {
         [aug[col], aug[max_row]] = [aug[max_row], aug[col]];
         // Eliminate column
         const pivot = aug[col][col];
-        for (let jdx = 0; jdx < 2 * n; jdx++) {
+        for (let jdx = 0; jdx < 2 * size; jdx++) {
             aug[col][jdx] /= pivot;
         }
-        for (let row = 0; row < n; row++) {
+        for (let row = 0; row < size; row++) {
             if (row !== col) {
                 const factor = aug[row][col];
-                for (let jdx = 0; jdx < 2 * n; jdx++) {
+                for (let jdx = 0; jdx < 2 * size; jdx++) {
                     aug[row][jdx] -= factor * aug[col][jdx];
                 }
             }
         }
     }
     // Extract inverse
-    return aug.map((row) => row.slice(n));
+    return aug.map((row) => row.slice(size));
 }

package/dist/plot/{data-transform.d.ts → core/data-transform.d.ts}

@@ -1,5 +1,5 @@
-import type { D3SymbolName } from '../labels';
-import type { DataSeries, Point } from './';
+import type { D3SymbolName } from '../../labels';
+import type { DataSeries, Point } from '..';
 export declare const get_series_color: (series_idx: number) => string;
 export declare const get_series_symbol: (series_idx: number) => D3SymbolName;
 export declare const extract_series_color: (series_data: DataSeries) => string;

package/dist/plot/{data-transform.js → core/data-transform.js}

@@ -1,15 +1,15 @@
 import { DEFAULT_SERIES_COLORS, DEFAULT_SERIES_SYMBOLS } from './types';
-import { DEFAULTS } from '../settings';
+import { DEFAULTS } from '../../settings';
 // Get auto-cycling color for series at given index (wraps every 10)
 export const get_series_color = (series_idx) => DEFAULT_SERIES_COLORS[series_idx % DEFAULT_SERIES_COLORS.length];
 // Get auto-cycling symbol for series at given index (wraps every 7)
 export const get_series_symbol = (series_idx) => DEFAULT_SERIES_SYMBOLS[series_idx % DEFAULT_SERIES_SYMBOLS.length];
 // Extract the primary color from a series data object.
 // Checks line stroke, then point fill (handling arrays), with fallback to default blue.
-export const extract_series_color = (series_data) => series_data.line_style?.stroke ||
+export const extract_series_color = (series_data) => (series_data.line_style?.stroke ??
     (Array.isArray(series_data.point_style)
         ? series_data.point_style[0]?.fill
-        : series_data.point_style?.fill) ||
+        : series_data.point_style?.fill)) || // oxlint-disable-line @typescript-eslint/prefer-nullish-coalescing -- empty fill should use default color
     `#4A9EFF`;
 // Prepare legend data from series array
 export const prepare_legend_data = (series) => series.map((series_data, series_idx) => ({

package/dist/plot/core/fill-utils.d.ts

@@ -0,0 +1,34 @@
+import type { Vec2 } from '../../math';
+import type { DataSeries, ErrorBand, FillBoundary, FillCurveType, FillGradient, FillRegion } from './types';
+export declare const LOG_EPSILON = 1e-10;
+export interface Pt {
+    x: number;
+    y: number;
+}
+export interface ResolvedBoundary {
+    points: Pt[];
+    curve: FillCurveType;
+}
+export interface FillSegment {
+    upper: Pt[];
+    lower: Pt[];
+    upper_curve: FillCurveType;
+    lower_curve: FillCurveType;
+}
+export declare function resolve_series_ref(ref: {
+    type: `series`;
+    series_idx?: number;
+    series_id?: string | number;
+}, series: readonly DataSeries[]): DataSeries | null;
+export declare function monotone_interpolate(xs: readonly number[], ys: readonly number[], x: number, tangents?: readonly number[]): number;
+interface DomainContext {
+    x_domain: Vec2;
+    y_domain: Vec2;
+    y2_domain?: Vec2;
+}
+export declare function resolve_boundary_points(boundary: FillBoundary, series: readonly DataSeries[], domains: DomainContext, companion?: Pt[] | null): ResolvedBoundary | null;
+export declare function compute_fill_segments(region: FillRegion, series: readonly DataSeries[], domains: DomainContext): FillSegment[];
+export declare function generate_fill_path(upper: readonly Pt[], lower: readonly Pt[], upper_curve?: FillCurveType, lower_curve?: FillCurveType): string;
+export declare function convert_error_band_to_fill_region(error_band: ErrorBand, series: readonly DataSeries[], default_color?: string): FillRegion | null;
+export declare const is_fill_gradient: (fill: string | FillGradient | undefined) => fill is FillGradient;
+export {};