matterviz 0.3.1 → 0.3.3

package/dist/plot/ZeroLines.svelte.d.ts

@@ -0,0 +1,32 @@
+import type { Vec2 } from '../math';
+import { type ScaleType, type Sides } from './';
+type $$ComponentProps = {
+    display: {
+        x_zero_line?: boolean;
+        x2_zero_line?: boolean;
+        y_zero_line?: boolean;
+        y2_zero_line?: boolean;
+    };
+    x_scale_fn: (val: number) => number;
+    x2_scale_fn?: (val: number) => number;
+    y_scale_fn: (val: number) => number;
+    y2_scale_fn?: (val: number) => number;
+    x_range: Vec2;
+    x2_range?: Vec2;
+    y_range: Vec2;
+    y2_range?: Vec2;
+    x_scale_type?: ScaleType;
+    x2_scale_type?: ScaleType;
+    y_scale_type?: ScaleType;
+    y2_scale_type?: ScaleType;
+    x_is_time?: boolean;
+    x2_is_time?: boolean;
+    has_x2?: boolean;
+    has_y2?: boolean;
+    width: number;
+    height: number;
+    pad: Required<Sides>;
+};
+declare const ZeroLines: import("svelte").Component<$$ComponentProps, {}, "">;
+type ZeroLines = ReturnType<typeof ZeroLines>;
+export default ZeroLines;

package/dist/plot/ZoomRect.svelte

@@ -0,0 +1,23 @@
+<script lang="ts">
+  import type { XyObj } from './'
+
+  let { start, current }: { start: XyObj | null; current: XyObj | null } = $props()
+</script>
+
+{#if start && current && isFinite(start.x) && isFinite(start.y) &&
+    isFinite(current.x) && isFinite(current.y)}
+  {@const x = Math.min(start.x, current.x)}
+  {@const y = Math.min(start.y, current.y)}
+  {@const rect_width = Math.abs(start.x - current.x)}
+  {@const rect_height = Math.abs(start.y - current.y)}
+  <rect class="zoom-rect" {x} {y} width={rect_width} height={rect_height} />
+{/if}
+
+<style>
+  .zoom-rect {
+    fill: var(--plot-zoom-rect-fill, rgba(100, 100, 255, 0.2));
+    stroke: var(--plot-zoom-rect-stroke, rgba(100, 100, 255, 0.8));
+    stroke-width: var(--plot-zoom-rect-stroke-width, 1);
+    pointer-events: none;
+  }
+</style>

package/dist/plot/ZoomRect.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { XyObj } from './';
+type $$ComponentProps = {
+    start: XyObj | null;
+    current: XyObj | null;
+};
+declare const ZoomRect: import("svelte").Component<$$ComponentProps, {}, "">;
+type ZoomRect = ReturnType<typeof ZoomRect>;
+export default ZoomRect;

package/dist/plot/axis-utils.d.ts

@@ -1,5 +1,5 @@
 import type { AxisConfig, AxisLoadError, BarSeries, DataLoaderFn, DataSeries } from './types';
-type AxisType = `x` | `y` | `y2`;
+type AxisType = `x` | `x2` | `y` | `y2`;
 export declare function merge_series_state<T extends DataSeries | BarSeries>(old_series: T[], new_series: T[]): T[];
 export interface AxisChangeState<T extends DataSeries | BarSeries> {
     get_axis: (axis: AxisType) => AxisConfig;

package/dist/plot/axis-utils.js

@@ -10,9 +10,7 @@ export function merge_series_state(old_series, new_series) {
     }
     return new_series.map((new_srs, idx) => {
         // Match by id if available (string or number), otherwise fall back to index
-        const old_srs = (new_srs.id !== undefined && new_srs.id !== ``
-            ? by_id.get(new_srs.id)
-            : undefined) ??
+        const old_srs = (new_srs.id !== undefined && new_srs.id !== `` ? by_id.get(new_srs.id) : undefined) ??
             old_series[idx];
         if (!old_srs) {
             return new_srs;

package/dist/plot/data-cleaning.js

@@ -21,9 +21,7 @@ export function compute_local_variance(values, window_size) {
         const start = Math.max(0, idx - half_window);
         const end = Math.min(len, idx + half_window + 1);
         // Welford's online variance calculation
-        let mean = 0;
-        let m2 = 0;
-        let count = 0;
+        let [mean, m2, count] = [0, 0, 0];
         for (let jdx = start; jdx < end; jdx++) {
             const val = values[jdx];
             if (!Number.isFinite(val))
@@ -170,13 +168,9 @@ export function detect_instability(x_values, y_values, config = {}) {
         }
     }
     if (valid_y.length < window_size * 2) {
-        return {
-            detected: false,
-            onset_index: -1,
-            onset_x: NaN,
-            combined_score: 0,
-            method_scores: { derivative_variance: 0, amplitude_growth: 0, sign_changes: 0 },
-        };
+        const method_scores = { derivative_variance: 0, amplitude_growth: 0, sign_changes: 0 };
+        const detected = false;
+        return { detected, onset_index: -1, onset_x: NaN, combined_score: 0, method_scores };
     }
     // Run all three detection methods
     const deriv_result = detect_derivative_variance(valid_y, window_size, threshold);
@@ -188,12 +182,12 @@ export function detect_instability(x_values, y_values, config = {}) {
         sign_changes: sign_result.score,
     };
     // Compute weighted combined score
-    const total_weight = weights.derivative_variance + weights.amplitude_growth +
-        weights.sign_changes;
+    const total_weight = weights.derivative_variance + weights.amplitude_growth + weights.sign_changes;
     const combined_score = total_weight > 0
         ? (weights.derivative_variance * deriv_result.score +
             weights.amplitude_growth * amp_result.score +
-            weights.sign_changes * sign_result.score) / total_weight
+            weights.sign_changes * sign_result.score) /
+            total_weight
         : 0;
     // Find earliest onset across all methods that exceeded threshold
     const onset_candidates = [
@@ -214,16 +208,8 @@ export function detect_instability(x_values, y_values, config = {}) {
         }
     }
     const detected = combined_score >= threshold || onset_index >= 0;
-    const onset_x = onset_index >= 0 && onset_index < x_values.length
-        ? x_values[onset_index]
-        : NaN;
-    return {
-        detected,
-        onset_index,
-        onset_x,
-        combined_score,
-        method_scores,
-    };
+    const onset_x = onset_index >= 0 && onset_index < x_values.length ? x_values[onset_index] : NaN;
+    return { detected, onset_index, onset_x, combined_score, method_scores };
 }
 // --- Smoothing Functions ---
 // Moving average - O(n)
@@ -235,8 +221,7 @@ export function smooth_moving_average(values, window) {
     for (let idx = 0; idx < values.length; idx++) {
         const start = Math.max(0, idx - half_window);
         const end = Math.min(values.length, idx + half_window + 1);
-        let sum = 0;
-        let count = 0;
+        let [sum, count] = [0, 0];
         for (let jdx = start; jdx < end; jdx++) {
             if (Number.isFinite(values[jdx])) {
                 sum += values[jdx];
@@ -291,8 +276,7 @@ export function smooth_savitzky_golay(values, window, polynomial_order = DEFAULT
     // Cache coefficient sum to avoid O(n × window) redundant reductions in loop
     const coeffs_sum = coeffs.reduce((a, b) => a + b, 0);
     for (let idx = 0; idx < values.length; idx++) {
-        let sum = 0;
-        let weight_sum = 0;
+        let [sum, weight_sum] = [0, 0];
         for (let jdx = 0; jdx < actual_window; jdx++) {
             const data_idx = idx - half + jdx;
             if (data_idx >= 0 && data_idx < values.length && Number.isFinite(values[data_idx])) {
@@ -300,7 +284,7 @@ export function smooth_savitzky_golay(values, window, polynomial_order = DEFAULT
                 weight_sum += coeffs[jdx];
             }
         }
-        result[idx] = weight_sum !== 0 ? sum / weight_sum * coeffs_sum : values[idx];
+        result[idx] = weight_sum !== 0 ? (sum / weight_sum) * coeffs_sum : values[idx];
     }
     return result;
 }

package/dist/plot/data-transform.js

@@ -17,6 +17,7 @@ export const prepare_legend_data = (series) => series.map((series_data, series_i
     label: series_data.label ?? `Series ${series_idx + 1}`,
     visible: series_data.visible ?? true,
     display_style: {
+        // Prefer the series’ symbol when present, falling back to settings
         symbol_type: !Array.isArray(series_data.point_style)
             ? (series_data.point_style?.symbol_type ?? DEFAULTS.scatter.symbol_type)
             : DEFAULTS.scatter.symbol_type,
@@ -38,7 +39,7 @@ export const create_data_points = (series, filter_fn) => series
 // If prop is a scalar, returns the scalar (applied to all indices).
 // Returns undefined if prop is null/undefined.
 export function process_prop(prop, idx) {
-    if (prop === null || prop === undefined)
+    if (prop == null)
         return undefined;
     return Array.isArray(prop) ? prop[idx] : prop;
 }

package/dist/plot/fill-utils.js

@@ -113,6 +113,8 @@ export function resolve_boundary(boundary, series, x_values, domains) {
         case `function`:
             return x_values.map((curr_x) => boundary.fn(curr_x));
         case `data`:
+            if (boundary.values.length === 0)
+                return Array(x_values.length).fill(NaN);
             // If lengths match, use directly; otherwise interpolate
             if (boundary.values.length === x_values.length) {
                 return [...boundary.values];

package/dist/plot/index.d.ts

@@ -4,17 +4,19 @@ export interface TweenedOptions<T> {
     easing?: (t: number) => number;
     interpolate?: (a: T, b: T) => (t: number) => T;
 }
+export { default as AxisLabel } from './AxisLabel.svelte';
 export { default as BarPlot } from './BarPlot.svelte';
 export { default as BarPlotControls } from './BarPlotControls.svelte';
 export { default as ColorBar } from './ColorBar.svelte';
 export { default as ColorScaleSelect } from './ColorScaleSelect.svelte';
+export * from './data-cleaning';
 export { default as ElementScatter } from './ElementScatter.svelte';
 export * from './fill-utils';
 export { default as FillArea } from './FillArea.svelte';
 export { default as Histogram } from './Histogram.svelte';
 export { default as HistogramControls } from './HistogramControls.svelte';
-export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
 export * from './interactions';
+export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
 export * from './layout';
 export { default as Line } from './Line.svelte';
 export { default as PlotControls } from './PlotControls.svelte';
@@ -36,4 +38,6 @@ export { default as SpacegroupBarPlot } from './SpacegroupBarPlot.svelte';
 export { default as Surface3D } from './Surface3D.svelte';
 export * from './svg';
 export * from './types';
-export * from './data-cleaning';
+export * from './utils';
+export { default as ZeroLines } from './ZeroLines.svelte';
+export { default as ZoomRect } from './ZoomRect.svelte';

package/dist/plot/index.js

@@ -1,14 +1,16 @@
+export { default as AxisLabel } from './AxisLabel.svelte';
 export { default as BarPlot } from './BarPlot.svelte';
 export { default as BarPlotControls } from './BarPlotControls.svelte';
 export { default as ColorBar } from './ColorBar.svelte';
 export { default as ColorScaleSelect } from './ColorScaleSelect.svelte';
+export * from './data-cleaning';
 export { default as ElementScatter } from './ElementScatter.svelte';
 export * from './fill-utils';
 export { default as FillArea } from './FillArea.svelte';
 export { default as Histogram } from './Histogram.svelte';
 export { default as HistogramControls } from './HistogramControls.svelte';
-export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
 export * from './interactions';
+export { default as InteractiveAxisLabel } from './InteractiveAxisLabel.svelte';
 export * from './layout';
 export { default as Line } from './Line.svelte';
 export { default as PlotControls } from './PlotControls.svelte';
@@ -30,4 +32,6 @@ export { default as SpacegroupBarPlot } from './SpacegroupBarPlot.svelte';
 export { default as Surface3D } from './Surface3D.svelte';
 export * from './svg';
 export * from './types';
-export * from './data-cleaning';
+export * from './utils';
+export { default as ZeroLines } from './ZeroLines.svelte';
+export { default as ZoomRect } from './ZoomRect.svelte';

package/dist/plot/interactions.d.ts

@@ -1,14 +1,12 @@
-import type { Y2SyncConfig, Y2SyncMode } from './types';
-export declare function get_relative_coords(evt: MouseEvent): {
-    x: number;
-    y: number;
-} | null;
+import type { Vec2 } from '../math';
+import type { XyObj, Y2SyncConfig, Y2SyncMode } from './types';
+export declare function get_relative_coords(evt: MouseEvent): XyObj | null;
 export declare function normalize_y2_sync(sync: Y2SyncConfig | Y2SyncMode | undefined): Y2SyncConfig;
-export declare function sync_y2_range(y1_range: [number, number], y2_base_range: [number, number], sync: Y2SyncConfig): [number, number];
-export declare function pan_range(current: [number, number], delta: number): [number, number];
-export declare function pixels_to_data_delta(pixel_delta: number, data_range: [number, number], pixel_range: number): number;
+export declare function sync_y2_range(y1_range: Vec2, y2_base_range: Vec2, sync: Y2SyncConfig): Vec2;
+export declare function pan_range(current: Vec2, delta: number): Vec2;
+export declare function pixels_to_data_delta(pixel_delta: number, data_range: Vec2, pixel_range: number): number;
 export declare const PINCH_ZOOM_THRESHOLD = 0.1;
-export declare function expand_range_if_needed(current: [number, number], new_range: [number, number]): {
-    range: [number, number];
+export declare function expand_range_if_needed(current: Vec2, new_range: Vec2): {
+    range: Vec2;
     changed: boolean;
 };

package/dist/plot/interactions.js

@@ -1,9 +1,8 @@
 // Get relative coordinates from a mouse event
 export function get_relative_coords(evt) {
     const current_target = evt.currentTarget;
-    if (!current_target || typeof current_target.getBoundingClientRect !== `function`) {
+    if (!(current_target instanceof SVGElement))
         return null;
-    }
     const svg_box = current_target.getBoundingClientRect();
     if (!svg_box)
         return null;
@@ -27,7 +26,7 @@ export function sync_y2_range(y1_range, y2_base_range, sync) {
         return y2_base_range;
     // Synced: Y2 has exact same range as Y1
     if (sync.mode === `synced`) {
-        return [...y1_range];
+        return [y1_range[0], y1_range[1]];
     }
     // Align: Position so align_val (default 0) is at same relative position on both axes
     // Y2 range expands as needed to show all data while maintaining alignment

package/dist/plot/layout.d.ts

@@ -1,10 +1,13 @@
 import type { AxisConfig, Sides } from './';
 export declare const LABEL_GAP_DEFAULT = 30;
-export declare const filter_padding: <T extends Partial<Sides>>(padding: T | undefined | null, defaults: Required<Sides>) => Required<Sides>;
+export declare const filter_padding: (padding: Partial<Sides> | undefined | null, defaults: Required<Sides>) => Required<Sides>;
 export declare function measure_text_width(text: string, font?: string): number;
 export interface AutoPaddingConfig {
     padding: Partial<Sides>;
     default_padding: Required<Sides>;
+    x2_axis?: AxisConfig & {
+        tick_values?: (string | number)[];
+    };
     y_axis?: AxisConfig & {
         tick_values?: (string | number)[];
     };
@@ -13,7 +16,10 @@ export interface AutoPaddingConfig {
     };
     label_gap?: number;
 }
-export declare const calc_auto_padding: ({ padding, default_padding, y_axis, y2_axis, label_gap, }: AutoPaddingConfig) => Required<Sides>;
+export declare const measure_max_tick_width: (ticks: (string | number)[], format?: string) => number;
+export declare const TICK_LABEL_HEIGHT = 16;
+export declare const AXIS_LABEL_HEIGHT = 20;
+export declare const calc_auto_padding: ({ padding, default_padding, x2_axis, y_axis, y2_axis, label_gap, }: AutoPaddingConfig) => Required<Sides>;
 export declare function constrain_tooltip_position(cursor_x: number, cursor_y: number, tooltip_width: number, tooltip_height: number, viewport_width: number, viewport_height: number, options?: {
     offset?: number;
     offset_x?: number;
@@ -28,6 +34,9 @@ export interface Rect {
     width: number;
     height: number;
 }
+export declare const pad_rect: (rect: Rect, padding: number) => Rect;
+export declare const centered_rect: (center_x: number, top_y: number, width: number, height: number) => Rect;
+export declare const rect_within_rect: (rect: Rect, bounds: Rect) => boolean;
 export interface ElementPlacementConfig {
     plot_bounds: Rect;
     element_size: {

package/dist/plot/layout.js

@@ -22,18 +22,28 @@ export function measure_text_width(text, font = `12px sans-serif`) {
     ctx.font = font;
     return ctx.measureText(text).width;
 }
-// Helper to measure max tick width
-const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0 ? 0 : Math.max(...ticks.map((tick) => {
-    const label = typeof tick === `string` ? tick : format_value(tick, format);
-    return measure_text_width(label, `12px sans-serif`);
-}));
-export const calc_auto_padding = ({ padding, default_padding, y_axis = {}, y2_axis = {}, label_gap = LABEL_GAP_DEFAULT, }) => {
+// Measure the widest formatted tick label. Used for auto-padding and label placement.
+export const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0
+    ? 0
+    : Math.max(...ticks.map((tick) => {
+        const label = typeof tick === `string` ? tick : format_value(tick, format);
+        return measure_text_width(label, `12px sans-serif`);
+    }));
+// Estimated height of a single tick label line (font-size 0.8em ≈ 12px + leading)
+export const TICK_LABEL_HEIGHT = 16;
+// Estimated height of an axis label (font-size ~14px + margin)
+export const AXIS_LABEL_HEIGHT = 20;
+export const calc_auto_padding = ({ padding, default_padding, x2_axis = {}, y_axis = {}, y2_axis = {}, label_gap = LABEL_GAP_DEFAULT, }) => {
+    const x2_ticks = x2_axis.tick_values ?? [];
     const y_ticks = y_axis.tick_values ?? [];
     const y_format = y_axis.format ?? ``;
     const y2_ticks = y2_axis.tick_values ?? [];
     const y2_format = y2_axis.format ?? ``;
     return {
-        t: padding.t ?? default_padding.t,
+        t: padding.t ??
+            (x2_ticks.length > 0
+                ? Math.max(default_padding.t, TICK_LABEL_HEIGHT + label_gap + (x2_axis.label ? AXIS_LABEL_HEIGHT : 0))
+                : default_padding.t),
         b: padding.b ?? default_padding.b,
         l: padding.l ??
             Math.max(default_padding.l, measure_max_tick_width(y_ticks, y_format) + label_gap),
@@ -60,18 +70,22 @@ export function constrain_tooltip_position(cursor_x, cursor_y, tooltip_width, to
     const abs_offset_y = Math.abs(offset_y);
     // Determine X position based on preferred side and flip state
     let raw_x;
-    if (offset_x >= 0) { // Prefer right side: flip to left if overflows
+    if (offset_x >= 0) {
+        // Prefer right side: flip to left if overflows
         raw_x = flip_x ? cursor_x - abs_offset_x - tooltip_width : cursor_x + abs_offset_x;
     }
-    else { // Prefer left side: flip to right if overflows
+    else {
+        // Prefer left side: flip to right if overflows
         raw_x = flip_x ? cursor_x + abs_offset_x : cursor_x - abs_offset_x - tooltip_width;
     }
     // Determine Y position based on preferred side and flip state
     let raw_y;
-    if (offset_y >= 0) { // Prefer bottom: flip to top if overflows
+    if (offset_y >= 0) {
+        // Prefer bottom: flip to top if overflows
         raw_y = flip_y ? cursor_y - abs_offset_y - tooltip_height : cursor_y + abs_offset_y;
     }
-    else { // Prefer top: flip to bottom if overflows
+    else {
+        // Prefer top: flip to bottom if overflows
         raw_y = flip_y ? cursor_y + abs_offset_y : cursor_y - abs_offset_y - tooltip_height;
     }
     // Clamp to viewport bounds
@@ -79,6 +93,22 @@ export function constrain_tooltip_position(cursor_x, cursor_y, tooltip_width, to
     const y_pos = Math.max(0, Math.min(raw_y, viewport_height - tooltip_height));
     return { x: x_pos, y: y_pos };
 }
+export const pad_rect = (rect, padding) => ({
+    x: rect.x - padding,
+    y: rect.y - padding,
+    width: rect.width + 2 * padding,
+    height: rect.height + 2 * padding,
+});
+export const centered_rect = (center_x, top_y, width, height) => ({
+    x: center_x - width / 2,
+    y: top_y,
+    width,
+    height,
+});
+export const rect_within_rect = (rect, bounds) => rect.x >= bounds.x &&
+    rect.x + rect.width <= bounds.x + bounds.width &&
+    rect.y >= bounds.y &&
+    rect.y + rect.height <= bounds.y + bounds.height;
 // Scoring constants
 const EXCLUSION_PENALTY = 1000;
 const DISTANCE_WEIGHT = 0.001;
@@ -121,7 +151,7 @@ export function compute_element_placement(config) {
     const effective_y_max = Math.max(valid_y_min, valid_y_max);
     // Subsample points for performance
     const sampled_points = points.length > MAX_SAMPLE_POINTS
-        ? Array.from({ length: MAX_SAMPLE_POINTS }, (_, idx) => points[Math.floor(idx * points.length / MAX_SAMPLE_POINTS)])
+        ? Array.from({ length: MAX_SAMPLE_POINTS }, (_, idx) => points[Math.floor((idx * points.length) / MAX_SAMPLE_POINTS)])
         : points;
     let best_result = {
         x: effective_x_min,
@@ -189,11 +219,8 @@ export function compute_element_placement(config) {
             euclidean_dist([cand_x, elem_bottom], [plot_left, plot_bottom]), // bottom-left
             euclidean_dist([elem_right, elem_bottom], [plot_right, plot_bottom]));
             // Higher bonus for positions closer to corners (0 = at corner, 1 = far from all)
-            const corner_bonus = max_corner_dist > 0
-                ? (1 - min_corner_dist / max_corner_dist) * CORNER_WEIGHT
-                : 0;
-            const score = -overlap_count + min_distance * DISTANCE_WEIGHT + corner_bonus -
-                exclusion_penalty;
+            const corner_bonus = max_corner_dist > 0 ? (1 - min_corner_dist / max_corner_dist) * CORNER_WEIGHT : 0;
+            const score = -overlap_count + min_distance * DISTANCE_WEIGHT + corner_bonus - exclusion_penalty;
             if (score > best_result.score) {
                 best_result = { x: cand_x, y: cand_y, score };
             }

package/dist/plot/reference-line.d.ts

@@ -1,5 +1,4 @@
-import type { Vec3 } from '../math';
-import type { RefLine, RefLine3D, RefLine3DBase, RefLineBase, RefLineValue, RefPlane, RefPlaneBase } from './types';
+import type { RefLine, RefLineValue } from './types';
 export type IndexedRefLine = RefLine & {
     idx: number;
 };
@@ -12,31 +11,15 @@ export interface RefLinesByZIndex {
 }
 export declare function group_ref_lines_by_z(lines: IndexedRefLine[]): RefLinesByZIndex;
 export declare function normalize_value(value: RefLineValue): number;
-export declare function normalize_point(point: [RefLineValue, RefLineValue]): [number, number];
-export declare function horizontal_line(y_value: RefLineValue, opts?: Partial<RefLineBase>): RefLine;
-export declare function vertical_line(x_value: RefLineValue, opts?: Partial<RefLineBase>): RefLine;
-export declare function diagonal_line(slope: number, intercept: number, opts?: Partial<RefLineBase>): RefLine;
-export declare function line_segment(p1: [RefLineValue, RefLineValue], p2: [RefLineValue, RefLineValue], opts?: Partial<RefLineBase>): RefLine;
-export declare function line_through(p1: [RefLineValue, RefLineValue], p2: [RefLineValue, RefLineValue], opts?: Partial<RefLineBase>): RefLine;
-export declare function horizontal_lines(values: RefLineValue[], opts?: Partial<RefLineBase>): RefLine[];
-export declare function vertical_lines(values: RefLineValue[], opts?: Partial<RefLineBase>): RefLine[];
-export declare function plane_xy(z_value: number, opts?: Partial<RefPlaneBase>): RefPlane;
-export declare function plane_xz(y_value: number, opts?: Partial<RefPlaneBase>): RefPlane;
-export declare function plane_yz(x_value: number, opts?: Partial<RefPlaneBase>): RefPlane;
-export declare function plane_normal(normal: Vec3, point: Vec3, opts?: Partial<RefPlaneBase>): RefPlane;
-export declare function plane_through_points(p1: Vec3, p2: Vec3, p3: Vec3, opts?: Partial<RefPlaneBase>): RefPlane;
-export declare function line_x_axis(y_value: number, z_value: number, opts?: Partial<RefLine3DBase>): RefLine3D;
-export declare function line_y_axis(x_value: number, z_value: number, opts?: Partial<RefLine3DBase>): RefLine3D;
-export declare function line_z_axis(x_value: number, y_value: number, opts?: Partial<RefLine3DBase>): RefLine3D;
-export declare function line_segment_3d(p1: [number, number, number], p2: [number, number, number], opts?: Partial<RefLine3DBase>): RefLine3D;
-export declare function line_through_3d(p1: [number, number, number], p2: [number, number, number], opts?: Partial<RefLine3DBase>): RefLine3D;
-export declare function resolve_line_endpoints(ref_line: RefLine, { x_min, x_max, y_min, y_max }: {
+export declare const normalize_point: (point: [RefLineValue, RefLineValue]) => [number, number];
+export declare function resolve_line_endpoints(ref_line: RefLine, { x_min, x_max, y_min, y_max, }: {
     x_min: number;
     x_max: number;
     y_min: number;
     y_max: number;
-}, { x_scale, y_scale, y2_scale }: {
+}, { x_scale, x2_scale, y_scale, y2_scale, }: {
     x_scale: (val: number) => number;
+    x2_scale?: (val: number) => number;
     y_scale: (val: number) => number;
     y2_scale?: (val: number) => number;
 }): [number, number, number, number] | null;

package/dist/plot/reference-line.js

@@ -48,77 +48,10 @@ export function normalize_value(value) {
     return 0;
 }
 // Normalize a point tuple
-export function normalize_point(point) {
-    return [normalize_value(point[0]), normalize_value(point[1])];
-}
-// Create a horizontal reference line at y = value
-export function horizontal_line(y_value, opts) {
-    return { type: `horizontal`, y: y_value, ...opts };
-}
-// Create a vertical reference line at x = value
-export function vertical_line(x_value, opts) {
-    return { type: `vertical`, x: x_value, ...opts };
-}
-// Create a diagonal reference line with y = slope * x + intercept
-export function diagonal_line(slope, intercept, opts) {
-    return { type: `diagonal`, slope, intercept, ...opts };
-}
-// Create a line segment between two points
-export function line_segment(p1, p2, opts) {
-    return { type: `segment`, p1, p2, ...opts };
-}
-// Create a line through two points, extended to plot edges
-export function line_through(p1, p2, opts) {
-    return { type: `line`, p1, p2, ...opts };
-}
-// Batch helper: create multiple horizontal lines
-export function horizontal_lines(values, opts) {
-    return values.map((y_value) => horizontal_line(y_value, opts));
-}
-// Batch helper: create multiple vertical lines
-export function vertical_lines(values, opts) {
-    return values.map((x_value) => vertical_line(x_value, opts));
-}
-// Create an XY plane at z = value (horizontal plane)
-export function plane_xy(z_value, opts) {
-    return { type: `xy`, z: z_value, ...opts };
-}
-// Create an XZ plane at y = value
-export function plane_xz(y_value, opts) {
-    return { type: `xz`, y: y_value, ...opts };
-}
-// Create a YZ plane at x = value
-export function plane_yz(x_value, opts) {
-    return { type: `yz`, x: x_value, ...opts };
-}
-// Create a plane defined by normal vector and a point on the plane
-export function plane_normal(normal, point, opts) {
-    return { type: `normal`, normal, point, ...opts };
-}
-// Create a plane through three points
-export function plane_through_points(p1, p2, p3, opts) {
-    return { type: `points`, p1, p2, p3, ...opts };
-}
-// Create a 3D line parallel to x-axis at given y, z
-export function line_x_axis(y_value, z_value, opts) {
-    return { type: `x-axis`, y: y_value, z: z_value, ...opts };
-}
-// Create a 3D line parallel to y-axis at given x, z
-export function line_y_axis(x_value, z_value, opts) {
-    return { type: `y-axis`, x: x_value, z: z_value, ...opts };
-}
-// Create a 3D line parallel to z-axis at given x, y
-export function line_z_axis(x_value, y_value, opts) {
-    return { type: `z-axis`, x: x_value, y: y_value, ...opts };
-}
-// Create a 3D line segment between two points
-export function line_segment_3d(p1, p2, opts) {
-    return { type: `segment`, p1, p2, ...opts };
-}
-// Create a 3D line through two points, extended to bounds
-export function line_through_3d(p1, p2, opts) {
-    return { type: `line`, p1, p2, ...opts };
-}
+export const normalize_point = (point) => [
+    normalize_value(point[0]),
+    normalize_value(point[1]),
+];
 // Clip a line segment to a rectangle using Liang-Barsky algorithm
 // Returns clipped [x1, y1, x2, y2] or null if segment is entirely outside
 function clip_segment_to_rect(p1x, p1y, p2x, p2y, x_min, x_max, y_min, y_max) {
@@ -147,17 +80,13 @@ function clip_segment_to_rect(p1x, p1y, p2x, p2y, x_min, x_max, y_min, y_max) {
     }
     if (t_enter > t_leave)
         return null; // Segment entirely outside
-    return [
-        p1x + t_enter * dx,
-        p1y + t_enter * dy,
-        p1x + t_leave * dx,
-        p1y + t_leave * dy,
-    ];
+    return [p1x + t_enter * dx, p1y + t_enter * dy, p1x + t_leave * dx, p1y + t_leave * dy];
 }
 // Compute the screen coordinates for a reference line
 // Returns [x1, y1, x2, y2] in pixel coordinates, or null if line is not visible
-export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max }, { x_scale, y_scale, y2_scale }) {
-    // Determine which y-scale to use
+export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max, }, { x_scale, x2_scale, y_scale, y2_scale, }) {
+    // Determine which scales to use based on axis assignment
+    const active_x_scale = ref_line.x_axis === `x2` && x2_scale ? x2_scale : x_scale;
     const active_y_scale = ref_line.y_axis === `y2` && y2_scale ? y2_scale : y_scale;
     // Check if value is within plot bounds (for visibility)
     const is_x_visible = (x_val) => x_val >= x_min && x_val <= x_max;
@@ -273,9 +202,9 @@ export function resolve_line_endpoints(ref_line, { x_min, x_max, y_min, y_max },
         return null;
     }
     // Convert data coordinates to screen pixels
-    const x1_px = x_scale(x1_data);
+    const x1_px = active_x_scale(x1_data);
     const y1_px = active_y_scale(y1_data);
-    const x2_px = x_scale(x2_data);
+    const x2_px = active_x_scale(x2_data);
     const y2_px = active_y_scale(y2_data);
     // Validate that pixels are finite
     if (!isFinite(x1_px) || !isFinite(y1_px) || !isFinite(x2_px) || !isFinite(y2_px)) {
@@ -317,7 +246,7 @@ export function calculate_annotation_position(x1, y1, x2, y2, annotation) {
         if (side === `above` || side === `below`) {
             // In SVG, y increases downward. Flip sign if 'above' and perpendicular points down (ny > 0),
             // or if 'below' and perpendicular points up (ny <= 0), to ensure offset is in correct direction
-            const sign = (side === `above`) === (ny > 0) ? -1 : 1;
+            const sign = (side === `above`) === ny > 0 ? -1 : 1;
             perp_x = sign * nx * gap;
             perp_y = sign * ny * gap;
         }
@@ -341,8 +270,7 @@ export function calculate_annotation_position(x1, y1, x2, y2, annotation) {
         text_anchor = `start`; // text starts at gap point, extends right
     }
     else {
-        text_anchor = ({ start: `start`, end: `end`, center: `middle` }[position] ??
-            `middle`);
+        text_anchor = ({ start: `start`, end: `end`, center: `middle` }[position] ?? `middle`);
     }
     const dominant_baseline = ({
         above: `auto`,