matterviz 0.3.7 → 0.4.1

package/dist/plot/interactions.js

@@ -1,101 +0,0 @@
-// Get relative coordinates from a mouse event
-export function get_relative_coords(evt) {
-    const current_target = evt.currentTarget;
-    if (!(current_target instanceof SVGElement))
-        return null;
-    const svg_box = current_target.getBoundingClientRect();
-    if (!svg_box)
-        return null;
-    return { x: evt.clientX - svg_box.left, y: evt.clientY - svg_box.top };
-}
-// Normalize Y2 sync config (handle shorthand string vs full object)
-export function normalize_y2_sync(sync) {
-    if (!sync || sync === `none`)
-        return { mode: `none` };
-    if (typeof sync === `string`)
-        return { mode: sync };
-    return sync;
-}
-// Helper to check if all values in ranges are finite
-const all_finite = (...ranges) => ranges.every(([a, b]) => Number.isFinite(a) && Number.isFinite(b));
-// Calculate synced y2 range based on sync mode
-export function sync_y2_range(y1_range, y2_base_range, sync) {
-    if (sync.mode === `none`)
-        return y2_base_range;
-    if (!all_finite(y1_range, y2_base_range))
-        return y2_base_range;
-    // Synced: Y2 has exact same range as Y1
-    if (sync.mode === `synced`) {
-        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
-    if (sync.mode === `align`) {
-        const align_val = sync.align_value ?? 0;
-        const y1_span = y1_range[1] - y1_range[0];
-        if (y1_span === 0)
-            return y2_base_range;
-        // Where is align_val in Y1's range? (0 = bottom, 1 = top)
-        const rel_pos = (align_val - y1_range[0]) / y1_span;
-        // Ensure Y2 range includes both align_val and all data
-        const y2_min_data = Math.min(y2_base_range[0], align_val);
-        const y2_max_data = Math.max(y2_base_range[1], align_val);
-        // Calculate minimum span needed to fit all data while keeping align_val at rel_pos
-        // Constraints: y2_min <= y2_min_data AND y2_max >= y2_max_data
-        let y2_span = y2_max_data - y2_min_data;
-        if (rel_pos > 0) {
-            y2_span = Math.max(y2_span, (align_val - y2_min_data) / rel_pos);
-        }
-        if (rel_pos < 1) {
-            y2_span = Math.max(y2_span, (y2_max_data - align_val) / (1 - rel_pos));
-        }
-        const y2_min_computed = align_val - rel_pos * y2_span;
-        const y2_max_computed = align_val + (1 - rel_pos) * y2_span;
-        // When align_val is outside y1_range (rel_pos < 0 or > 1), the formula can produce
-        // a range that omits y2_base_range or align_val. Ensure both are always included.
-        const y2_min = Math.min(y2_min_computed, y2_base_range[0], align_val);
-        const y2_max = Math.max(y2_max_computed, y2_base_range[1], align_val);
-        return [y2_min, y2_max];
-    }
-    return y2_base_range;
-}
-// Shift a range by a delta amount (no bounds constraint for free panning)
-export const pan_range = (current, delta) => [
-    current[0] + delta,
-    current[1] + delta,
-];
-// Convert pixel delta to data delta using current data range and pixel range
-export function pixels_to_data_delta(pixel_delta, data_range, pixel_range) {
-    if (pixel_range === 0)
-        return 0;
-    const data_span = data_range[1] - data_range[0];
-    return (pixel_delta / pixel_range) * data_span;
-}
-// Threshold for distinguishing pinch-zoom from pan in touch gestures
-// Scale change > this value triggers zoom instead of pan
-export const PINCH_ZOOM_THRESHOLD = 0.1;
-// Helper to check if range is the default [0, 1] sentinel (no data)
-// Note: min === 0 handles -0 correctly since -0 === 0 in JavaScript
-const is_default_range = ([min, max]) => min === 0 && max === 1;
-// Adopt the new data range, unless all series were hidden (sentinel [0, 1] fallback).
-// NOTE: [0, 1] is the "no data" sentinel - when all series are hidden, auto ranges
-// fall back to [0, 1]. Actual data spanning exactly [0, 1] is a rare edge case.
-export function expand_range_if_needed(current, new_range) {
-    // Guard against NaN/Infinity - prefer valid range, fall back to sentinel [0, 1] if both invalid
-    const current_valid = all_finite(current);
-    const new_valid = all_finite(new_range);
-    if (!current_valid && !new_valid)
-        return { range: [0, 1], changed: true };
-    if (!new_valid)
-        return { range: current, changed: false };
-    if (!current_valid)
-        return { range: new_range, changed: true };
-    // When all series are hidden, auto ranges fall back to [0, 1] sentinel.
-    // Don't shrink to that — preserve the current view so it doesn't jump.
-    if (!is_default_range(current) && is_default_range(new_range)) {
-        return { range: current, changed: false };
-    }
-    // Otherwise adopt the new range directly (both expand and shrink)
-    const changed = new_range[0] !== current[0] || new_range[1] !== current[1];
-    return { range: new_range, changed };
-}

package/dist/plot/scales.d.ts

@@ -1,48 +0,0 @@
-import type { D3ColorSchemeName, D3InterpolateName } from '../colors';
-import type { Point, ScaleType, TimeInterval } from './';
-import type { ScaleContinuousNumeric, ScaleTime } from 'd3-scale';
-export type TicksOption = number | number[] | TimeInterval | Record<number, string>;
-export interface ArcsinhScale {
-    (value: number | Date): number;
-    domain(): [number, number];
-    domain(domain: [number, number]): ArcsinhScale;
-    range(): [number, number];
-    range(range: [number, number]): ArcsinhScale;
-    invert(value: number): number;
-    copy(): ArcsinhScale;
-    ticks(count?: number): number[];
-    threshold: number;
-}
-export type PlotScaleFn = ScaleContinuousNumeric<number, number> | ScaleTime<number, number> | ArcsinhScale;
-export declare function scale_arcsinh(threshold?: number): ArcsinhScale;
-export declare function generate_arcsinh_ticks(min: number, max: number, threshold?: number, count?: number): number[];
-export declare function create_scale(scale_type: ScaleType, domain: [number, number], output_range: [number, number]): ScaleContinuousNumeric<number, number> | ArcsinhScale;
-export declare const create_time_scale: (domain: [number, number], output_range: [number, number]) => ScaleTime<number, number, never>;
-export declare function generate_ticks(domain: [number, number], scale_type: ScaleType, ticks_option: TicksOption | undefined, scale_fn: PlotScaleFn, // D3 scale function with .ticks() method
-options?: {
-    format?: string;
-    default_count?: number;
-    interval_padding?: number;
-}): number[];
-export declare function calculate_domain(values: number[], scale_type?: ScaleType): [number, number];
-export declare function get_nice_data_range(points: Point[], get_value: (p: Point) => number, limits: [number | null, number | null], scale_type: ScaleType, padding_factor: number, is_time?: boolean): [number, number];
-export declare function generate_log_ticks(min: number, max: number, ticks_option?: TicksOption): number[];
-export declare function get_tick_label(tick_value: number, ticks_option: TicksOption | undefined): string | null;
-export declare function create_color_scale(color_scale_config: {
-    type?: ScaleType;
-    scheme?: D3ColorSchemeName | D3InterpolateName;
-    value_range?: [number, number];
-} | string, auto_color_range: [number, number]): ((value: number) => string) & {
-    domain: {
-        (): [number, number];
-        (new_domain: [number, number]): ((value: number) => string) & /*elided*/ any;
-    };
-};
-export declare function create_size_scale(config: {
-    type?: ScaleType;
-    radius_range?: [number, number];
-    value_range?: [number, number];
-}, all_size_values: (number | null)[]): import("d3-scale").ScaleLinear<number, number, never> | (((value: number) => number) & {
-    domain: () => [number, number];
-    range: () => [number, number];
-});

package/dist/plot/svg.d.ts

@@ -1 +0,0 @@
-export declare function bar_path(x: number, y: number, w: number, h: number, r: number, vertical?: boolean): string;

package/dist/plot/svg.js

@@ -1,11 +0,0 @@
-// SVG path and rendering utilities for plot components.
-//
-// Generate SVG path for a bar with rounded corners on the "free" end (away from axis).
-// For vertical bars, rounds top corners. For horizontal bars, rounds right corners.
-export function bar_path(x, y, w, h, r, vertical = true) {
-    if (r <= 0)
-        return `M${x},${y}h${w}v${h}h${-w}Z`;
-    return vertical
-        ? `M${x},${y + h}V${y + r}A${r},${r} 0 0 1 ${x + r},${y}H${x + w - r}A${r},${r} 0 0 1 ${x + w},${y + r}V${y + h}Z`
-        : `M${x},${y}H${x + w - r}A${r},${r} 0 0 1 ${x + w},${y + r}V${y + h - r}A${r},${r} 0 0 1 ${x + w - r},${y + h}H${x}Z`;
-}

package/dist/plot/utils/series-visibility.d.ts

@@ -1,15 +0,0 @@
-import type { DataSeries } from '../types';
-export type StrRecord = Record<string, unknown>;
-type SeriesSource = [string, string, string, unknown, unknown];
-export type SeriesVisibilitySnapshot = {
-    visibility: boolean[];
-    source: SeriesSource[];
-};
-export declare function have_compatible_units<Metadata extends StrRecord = StrRecord>(series1: DataSeries<Metadata>, series2: DataSeries<Metadata>): boolean;
-export declare function toggle_series_visibility<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], series_idx: number): DataSeries<Metadata>[];
-export declare function toggle_group_visibility<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], series_indices: number[]): DataSeries<Metadata>[];
-export declare function handle_legend_double_click<Metadata extends StrRecord = StrRecord>(series: DataSeries<Metadata>[], idx: number, prev_snapshot: SeriesVisibilitySnapshot | null): {
-    series: DataSeries<Metadata>[];
-    prev_visibility: SeriesVisibilitySnapshot | null;
-};
-export {};

package/dist/plot/utils.d.ts

@@ -1 +0,0 @@
-export declare function calc_auto_range(values: number[]): [number, number];

package/dist/plot/utils.js

@@ -1,14 +0,0 @@
-export function calc_auto_range(values) {
-    const finite_values = values.filter(Number.isFinite);
-    if (finite_values.length === 0)
-        return [0, 1];
-    let [min_value, max_value] = [finite_values[0], finite_values[0]];
-    for (const value of finite_values) {
-        if (value < min_value)
-            min_value = value;
-        else if (value > max_value)
-            max_value = value;
-    }
-    const padding = (max_value - min_value) * 0.05 || 0.5;
-    return [min_value - padding, max_value + padding];
-}