matterviz 0.4.1 → 0.4.2

package/dist/plot/core/interactions.js

@@ -7,8 +7,6 @@ export function get_relative_coords(evt, element = evt.currentTarget) {
     if (!(element instanceof Element))
         return null;
     const box = element.getBoundingClientRect();
-    if (!box)
-        return null;
     return { x: evt.clientX - box.left, y: evt.clientY - box.top };
 }
 // Resolve a delegated event to the integer value of the nearest ancestor's data

package/dist/plot/core/layout.d.ts

@@ -5,7 +5,8 @@ export type Sides = {
     l?: number;
     r?: number;
 };
-export declare const LABEL_GAP_DEFAULT = 30;
+export declare const LABEL_GAP_DEFAULT = 20;
+export declare const DEFAULT_PLOT_PADDING: Required<Sides>;
 export declare function y2_axis_label_x(axis: AxisConfig, width: number, pad_r: number, max_tick_width: number): number;
 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;
@@ -30,6 +31,7 @@ export interface AutoPaddingConfig {
 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 AXIS_TITLE_OFFSET: number;
 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;

package/dist/plot/core/layout.js

@@ -1,7 +1,10 @@
 import { format_value } from '../../labels';
 import { euclidean_dist } from '../../math';
 // Default gap between tick labels and axis labels
-export const LABEL_GAP_DEFAULT = 30;
+export const LABEL_GAP_DEFAULT = 20;
+// Default plot padding (px) reserved for axis ticks/labels, shared by
+// Histogram/BarPlot/BoxPlot/BinnedScatterPlot (ScatterPlot keeps its own bespoke default)
+export const DEFAULT_PLOT_PADDING = { t: 20, b: 60, l: 60, r: 20 };
 // X position for a right-side (y2) axis label: past the plot edge plus tick shift and
 // measured tick-label width (both zero when tick labels render inside the plot)
 export function y2_axis_label_x(axis, width, pad_r, max_tick_width) {
@@ -56,22 +59,28 @@ export const measure_max_tick_width = (ticks, format = ``) => ticks.length === 0
 export const TICK_LABEL_HEIGHT = 16;
 // Estimated height of an axis label (font-size ~14px + margin)
 export const AXIS_LABEL_HEIGHT = 20;
+// Distance from an x/x2 axis baseline to the title center.
+export const AXIS_TITLE_OFFSET = TICK_LABEL_HEIGHT + LABEL_GAP_DEFAULT;
 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 ?? ``;
+    // Padding for a vertical-axis side (y/y2): when ticks render, reserve widest tick label + gap +
+    // the rotated axis-title width (mirrors the `t` branch's AXIS_LABEL_HEIGHT) so a wide tick label
+    // can't overlap the title. With no tick labels (e.g. no y2 series) reserve nothing extra.
+    const side_pad = (axis, default_side) => {
+        const ticks = axis.tick_values ?? [];
+        if (ticks.length === 0)
+            return default_side;
+        return Math.max(default_side, measure_max_tick_width(ticks, axis.format ?? ``) +
+            label_gap +
+            (axis.label ? AXIS_LABEL_HEIGHT : 0));
+    };
     return {
         t: padding.t ??
-            (x2_ticks.length > 0
+            ((x2_axis.tick_values ?? []).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),
-        r: padding.r ??
-            Math.max(default_padding.r, measure_max_tick_width(y2_ticks, y2_format) + label_gap),
+        l: padding.l ?? side_pad(y_axis, default_padding.l),
+        r: padding.r ?? side_pad(y2_axis, default_padding.r),
     };
 };
 // Constrain tooltip position within bounds, flipping to opposite side if overflow
@@ -216,9 +225,9 @@ export function compute_element_placement(config) {
         ? (effective_y_max - effective_y_min) / (grid_resolution - 1)
         : 0;
     // Precompute plot corners (constant across all candidates)
-    const plot_left = plot_bounds.x + axis_clearance;
+    const plot_left = valid_x_min;
     const plot_right = plot_bounds.x + plot_bounds.width - axis_clearance;
-    const plot_top = plot_bounds.y + axis_clearance;
+    const plot_top = valid_y_min;
     const plot_bottom = plot_bounds.y + plot_bounds.height - axis_clearance;
     const max_corner_dist = euclidean_dist([plot_left, plot_top], [plot_right, plot_bottom]);
     for (let grid_x = 0; grid_x < grid_resolution; grid_x++) {

package/dist/plot/core/marginals.d.ts

@@ -0,0 +1,170 @@
+import type { Vec2 } from '../../math';
+import type { Rect, Sides } from './layout';
+import type { LineCurve, ScaleType } from './types';
+import type { Snippet } from 'svelte';
+export type MarginalSide = `top` | `bottom` | `left` | `right`;
+export type MarginalType = `histogram` | `kde` | `cdf` | `rug`;
+export type MarginalPlacement = `auto` | `flush` | `outer`;
+export type MarginalNormalize = `count` | `density` | `probability`;
+export type MarginalAxisBinding = `x1` | `x2` | `y1` | `y2`;
+export declare const MARGINAL_SIDES: readonly ["top", "bottom", "left", "right"];
+export type MarginalCurve = {
+    kind: `bars`;
+    bins: {
+        pos0: number;
+        pos1: number;
+        value: number;
+    }[];
+    max: number;
+} | {
+    kind: `line`;
+    points: {
+        pos: number;
+        value: number;
+    }[];
+    max: number;
+} | {
+    kind: `rug`;
+    positions: number[];
+};
+export interface MarginalComputeContext {
+    config: ResolvedMarginalConfig;
+    side: MarginalSide;
+    positional_range: Vec2;
+    scale_type: ScaleType;
+}
+export interface MarginalConfig {
+    type?: MarginalType;
+    size?: number;
+    gap?: number;
+    placement?: MarginalPlacement;
+    axis?: MarginalAxisBinding;
+    bins?: number;
+    bandwidth?: number | `silverman` | `scott`;
+    normalize?: MarginalNormalize;
+    per_series?: boolean;
+    color?: string;
+    fill?: string;
+    fill_opacity?: number;
+    stroke?: string;
+    stroke_width?: number;
+    opacity?: number;
+    curve?: LineCurve;
+    value_range?: Vec2;
+    value_axis?: boolean;
+    label?: string;
+    data?: readonly number[] | ((ctx: MarginalComputeContext) => readonly number[]);
+    reduce?: (values: number[], weights: number[] | undefined, ctx: MarginalComputeContext) => MarginalCurve;
+    snippet?: Snippet<[MarginalRenderContext]>;
+    hover?: boolean;
+    tooltip?: Snippet<[MarginalHover]>;
+    class?: string;
+    style?: string;
+}
+export type ResolvedMarginalConfig = MarginalConfig & {
+    type: MarginalType;
+    size: number;
+    gap: number;
+    placement: MarginalPlacement;
+    per_series: boolean;
+    bins: number;
+    bandwidth: number | `silverman` | `scott`;
+    stroke_width: number;
+    opacity: number;
+    value_axis: boolean;
+};
+export type MarginalSideInput = boolean | MarginalType | MarginalConfig;
+export type MarginalsProp = boolean | MarginalType | Partial<Record<MarginalSide, MarginalSideInput>>;
+export type ResolvedMarginals = Record<MarginalSide, ResolvedMarginalConfig | null>;
+export interface MarginalSeriesInput {
+    x?: ArrayLike<number>;
+    y?: ArrayLike<number>;
+    weight?: ArrayLike<number>;
+    color: string;
+    label?: string;
+    visible?: boolean;
+    x_axis?: `x1` | `x2`;
+    y_axis?: `y1` | `y2`;
+}
+export interface MarginalSeriesCurve {
+    series_idx: number;
+    color: string;
+    label?: string;
+    curve: MarginalCurve;
+}
+export type ScaleFn = (value: number) => number;
+export interface MarginalAxis {
+    scale: ScaleFn;
+    range: Vec2;
+    scale_type?: ScaleType;
+    format?: string;
+    tick_label?: (value: number) => string | undefined;
+    label?: string;
+}
+export type MarginalAxes = {
+    x1: MarginalAxis;
+    x2?: MarginalAxis;
+    y1: MarginalAxis;
+    y2?: MarginalAxis;
+};
+export declare const marginal_axis: (scale: ScaleFn, range: Vec2, axis: {
+    scale_type?: ScaleType;
+    format?: string;
+    label?: string;
+}, tick_label?: (value: number) => string | undefined) => MarginalAxis;
+export interface MarginalRenderContext extends MarginalComputeContext {
+    rect: Rect;
+    positional_scale: ScaleFn;
+    value_scale: ScaleFn;
+    baseline: number;
+    curves: MarginalSeriesCurve[];
+    series: MarginalSeriesInput[];
+    format?: string;
+    tick_label?: (value: number) => string | undefined;
+    axis_title?: string;
+}
+export declare const MARGINAL_HIT_TOLERANCE_PX = 10;
+export interface MarginalHover {
+    side: MarginalSide;
+    x: number;
+    y: number;
+    color: string;
+    label?: string;
+    kind: MarginalCurve[`kind`];
+    pos: number;
+    pos0?: number;
+    pos1?: number;
+    value?: number;
+    config: ResolvedMarginalConfig;
+    scale_type: ScaleType;
+    format?: string;
+    pos_label?: string;
+    axis_title?: string;
+}
+export declare function marginal_hit(ctx: MarginalRenderContext, px: number, py: number): MarginalHover | null;
+export declare const MARGINAL_DEFAULTS: {
+    type: MarginalType;
+    size: number;
+    gap: number;
+    placement: MarginalPlacement;
+    per_series: boolean;
+    bins: number;
+    bandwidth: "silverman";
+    stroke_width: number;
+    opacity: number;
+    value_axis: boolean;
+};
+export declare function normalize_marginals(prop: MarginalsProp | undefined, default_sides?: Partial<Record<MarginalSide, MarginalSideInput>>): ResolvedMarginals;
+export declare function reserve_marginal_pad(resolved: ResolvedMarginals): Required<Sides>;
+export declare const add_sides: (a: Required<Sides>, b: Required<Sides>) => Required<Sides>;
+export declare const default_axis_for_side: (side: MarginalSide) => MarginalAxisBinding;
+export declare const marginal_axis_presence: (top: boolean, right: boolean) => Record<MarginalSide, boolean>;
+export declare function marginal_strip_rect(side: MarginalSide, pad: Required<Sides>, width: number, height: number, config: ResolvedMarginalConfig, has_axis: boolean): Rect;
+export declare function marginal_value_scale(side: MarginalSide, rect: Rect, domain: Vec2): {
+    scale: (value: number) => number;
+    baseline: number;
+};
+export declare function compute_marginal_curve(positions: ArrayLike<number>, weights: ArrayLike<number> | undefined, config: ResolvedMarginalConfig, positional_range: Vec2, scale_type: ScaleType): MarginalCurve;
+export declare const curves_max: (curves: MarginalCurve[]) => number;
+export declare const default_marginal_label: (config: ResolvedMarginalConfig) => string;
+export declare const marginal_value_format: (config: ResolvedMarginalConfig) => string;