matterviz 0.3.7 → 0.4.0

package/dist/plot/box/quantile.d.ts

@@ -0,0 +1,3 @@
+export declare function quickselect(values: number[], kth: number): number;
+export declare function quantile_sorted(values: readonly number[], p: number): number;
+export declare function quantile_unordered(values: number[], p: number): number;

package/dist/plot/box/quantile.js

@@ -0,0 +1,53 @@
+// Shared quantile + selection helpers used by box-plot.ts and kde.ts.
+// quickselect partially sorts in place; quantile_unordered mutates its input
+// (quantile_sorted assumes an already-ascending array and never mutates).
+//
+// Unguarded contract: quickselect, quantile_sorted and quantile_unordered all assume
+// values.length > 0 and 0 <= p <= 1. Out-of-range inputs index past the array and
+// yield undefined/NaN — callers (box-plot.ts, kde.ts) must length- and p-range-check
+// before calling.
+export function quickselect(values, kth) {
+    let left = 0;
+    let right = values.length - 1;
+    while (left < right) {
+        const pivot = values[(left + right) >>> 1];
+        let scan_lo = left;
+        let scan_hi = right;
+        while (scan_lo <= scan_hi) {
+            while (values[scan_lo] < pivot)
+                scan_lo++;
+            while (values[scan_hi] > pivot)
+                scan_hi--;
+            if (scan_lo <= scan_hi) {
+                const tmp = values[scan_lo];
+                values[scan_lo] = values[scan_hi];
+                values[scan_hi] = tmp;
+                scan_lo++;
+                scan_hi--;
+            }
+        }
+        if (kth <= scan_hi)
+            right = scan_hi;
+        else if (kth >= scan_lo)
+            left = scan_lo;
+        else
+            return values[kth];
+    }
+    return values[kth];
+}
+export function quantile_sorted(values, p) {
+    const idx = (values.length - 1) * p;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    const frac = idx - lo;
+    const lo_val = values[lo];
+    return hi === lo ? lo_val : lo_val + (values[hi] - lo_val) * frac;
+}
+export function quantile_unordered(values, p) {
+    const idx = (values.length - 1) * p;
+    const lo = Math.floor(idx);
+    const hi = Math.ceil(idx);
+    const frac = idx - lo;
+    const lo_val = quickselect(values, lo);
+    return hi === lo ? lo_val : lo_val + (quickselect(values, hi) - lo_val) * frac;
+}

package/dist/plot/{auto-place.js → core/auto-place.js}

@@ -1,4 +1,4 @@
-import { compute_element_placement, sample_series_obstacle_points } from './layout';
+import { compute_element_placement, sample_series_obstacle_points, } from './layout';
 // Shared "move a decoration (legend/colorbar) outside the plot when interior overlap is
 // unavoidable" logic, reused by every 2D plot (ScatterPlot/BarPlot/Histogram/BinnedScatterPlot).
 export const DECOR_GAP = 8; // px gap between an outside decoration and the plot edge
@@ -55,7 +55,7 @@ export function clip_bar(vertical, cross, a, b) {
 const CROWDING_RATIO = 0.5;
 // True when even the best interior spot for `footprint` (px) is too dense to host the decoration
 function is_crowded(obstacles, footprint, base_w, base_h, clearance) {
-    if (!obstacles.length || base_w <= 0 || base_h <= 0)
+    if (obstacles.length === 0 || base_w <= 0 || base_h <= 0)
         return false;
     const fw = footprint.width / base_w;
     const fh = footprint.height / base_h;

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

@@ -0,0 +1,46 @@
+import type { AxisConfig, AxisLoadError, BarSeries, DataLoaderFn, DataSeries } from './types';
+export declare const AXIS_DEFAULTS: {
+    format: string;
+    scale_type: "linear";
+    ticks: number;
+    label_shift: {
+        x: number;
+        y: number;
+    };
+    tick: {
+        label: {
+            shift: {
+                x: number;
+                y: number;
+            };
+            inside: boolean;
+        };
+    };
+    range: [number | null, number | null];
+};
+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;
+    set_axis: (axis: AxisType, config: AxisConfig) => void;
+    get_series: () => T[];
+    set_series: (series: T[]) => void;
+    get_loading: () => AxisType | null;
+    set_loading: (axis: AxisType | null) => void;
+}
+export declare const create_axis_change_handler: <T extends DataSeries | BarSeries>(state: AxisChangeState<T>, data_loader: DataLoaderFn<Record<string, unknown>, T> | undefined, on_axis_change?: (axis: AxisType, key: string, new_series: T[]) => void, on_error?: (error: AxisLoadError) => void) => ((axis: AxisType, key: string) => Promise<void>);
+export declare function create_axis_loader<T extends DataSeries | BarSeries>(state: AxisChangeState<T>, get_props: () => {
+    data_loader?: DataLoaderFn<Record<string, unknown>, T>;
+    on_axis_change?: (axis: AxisType, key: string, new_series: T[]) => void;
+    on_error?: (error: AxisLoadError) => void;
+}): {
+    handle_axis_change: (axis: AxisType, key: string) => Promise<void>;
+    try_auto_load: () => void;
+};
+export declare const AXIS_LABEL_CONTAINER: {
+    readonly width: 200;
+    readonly height: 24;
+    readonly x_offset: 100;
+    readonly y_offset: 12;
+};
+export {};

package/dist/plot/core/axis-utils.js

@@ -0,0 +1,110 @@
+// Shared utilities for interactive axis functionality
+import { to_error } from '../../utils';
+// Shared axis defaults across plot components (single source of truth)
+export const AXIS_DEFAULTS = {
+    format: ``,
+    scale_type: `linear`,
+    ticks: 5,
+    label_shift: { x: 0, y: 0 },
+    tick: { label: { shift: { x: 0, y: 0 }, inside: false } },
+    range: [null, null],
+};
+// Merge new series with preserved UI state from old series.
+// Matches by stable id first, then by index only for ordered id-less series.
+export function merge_series_state(old_series, new_series) {
+    // Build id lookup map for O(1) matching (string or number ids)
+    const by_id = new Map();
+    for (const srs of old_series) {
+        if (srs.id !== undefined && srs.id !== ``)
+            by_id.set(srs.id, srs);
+    }
+    return new_series.map((new_srs, idx) => {
+        const old_srs = new_srs.id !== undefined && new_srs.id !== `` ? by_id.get(new_srs.id) : old_series[idx];
+        if (!old_srs) {
+            return new_srs;
+        }
+        // Preserve UI state: visibility and styling from old series if not in new
+        const result = { ...new_srs };
+        result.visible ??= old_srs.visible;
+        // Preserve style properties only when key exists in BOTH series (guards against
+        // cross-type injection when T is a union like DataSeries | BarSeries)
+        for (const key of [`point_style`, `line_style`, `color`]) {
+            if (key in old_srs && key in new_srs && result[key] === undefined) {
+                result[key] = old_srs[key];
+            }
+        }
+        return result;
+    });
+}
+// Handle axis property change - loads new data via data_loader
+// Returns a function bound to the component's state accessors
+export const create_axis_change_handler = (state, data_loader, on_axis_change, on_error) => async (axis, key) => {
+    if (!data_loader || state.get_loading())
+        return;
+    const axis_config = state.get_axis(axis);
+    const prev_key = axis_config.selected_key;
+    // Skip if key unchanged AND series already loaded (allows initial load when series empty)
+    if (prev_key === key && state.get_series().length > 0)
+        return;
+    // Update selected_key immediately for UI feedback
+    state.set_axis(axis, { ...axis_config, selected_key: key });
+    state.set_loading(axis);
+    try {
+        const result = await data_loader(axis, key, state.get_series());
+        // Merge new series with preserved state from old series
+        const merged = merge_series_state(state.get_series(), result.series);
+        state.set_series(merged);
+        // Update axis label/unit if provided
+        if (result.axis_label || result.axis_unit) {
+            const current = state.get_axis(axis);
+            state.set_axis(axis, {
+                ...current,
+                label: result.axis_label ?? current.label,
+                unit: result.axis_unit ?? current.unit,
+            });
+        }
+        on_axis_change?.(axis, key, merged);
+    }
+    catch (err) {
+        console.error(`Failed to load data for ${axis}=${key}:`, err);
+        // Revert selection
+        state.set_axis(axis, { ...state.get_axis(axis), selected_key: prev_key });
+        const message = to_error(err).message;
+        on_error?.({ axis, key, message });
+    }
+    finally {
+        state.set_loading(null);
+    }
+};
+// Bundle axis change handler with one-shot auto-load of the first axis option.
+// get_props keeps callback props fresh; try_auto_load reads series/axis configs
+// through state getters so a component `$effect(try_auto_load)` tracks them reactively.
+export function create_axis_loader(state, get_props) {
+    let auto_load_attempted = false; // prevent infinite retries on failure
+    const handle_axis_change = (axis, key) => {
+        const { data_loader, on_axis_change, on_error } = get_props();
+        return create_axis_change_handler(state, data_loader, on_axis_change, on_error)(axis, key);
+    };
+    // Auto-load data if series is empty but options exist (runs once, x-axis first then y)
+    const try_auto_load = () => {
+        if (state.get_series().length > 0 || !get_props().data_loader || auto_load_attempted)
+            return;
+        for (const axis of [`x`, `y`]) {
+            const config = state.get_axis(axis);
+            if (config.options?.length) {
+                auto_load_attempted = true;
+                handle_axis_change(axis, config.selected_key ?? config.options[0].key).catch(() => { });
+                return;
+            }
+        }
+    };
+    return { handle_axis_change, try_auto_load };
+}
+// Constants for axis label foreignObject positioning (all values in px)
+// Use minimal dimensions - overflow: visible handles any dropdown expansion
+export const AXIS_LABEL_CONTAINER = {
+    width: 200, // container width for centering; dropdown can overflow
+    height: 24, // single line height; dropdown options overflow downward
+    x_offset: 100, // half of width for horizontal centering
+    y_offset: 12, // half of height for vertical centering
+};

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

@@ -1,6 +1,6 @@
 <script lang="ts">
-  import { AXIS_LABEL_CONTAINER } from './axis-utils'
-  import type { AxisOption } from './types'
+  import { AXIS_LABEL_CONTAINER } from '../axis-utils'
+  import type { AxisOption } from '../types'
   import InteractiveAxisLabel from './InteractiveAxisLabel.svelte'
 
   let {

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

@@ -1,4 +1,4 @@
-import type { AxisOption } from './types';
+import type { AxisOption } from '../types';
 type $$ComponentProps = {
     x: number;
     y: number;

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

@@ -1,26 +1,26 @@
 <script lang="ts">
-  import { luminance } from '../colors'
-  import Spinner from '../feedback/Spinner.svelte'
-  import { format_num } from '../labels'
-  import { sanitize_html } from '../sanitize'
-  import type { Vec2 } from '../math'
-  import * as math from '../math'
+  import { luminance } from '../../../colors'
+  import Spinner from '../../../feedback/Spinner.svelte'
+  import { format_num } from '../../../labels'
+  import { sanitize_html } from '../../../sanitize'
+  import type { Vec2 } from '../../../math'
+  import * as math from '../../../math'
   import { format } from 'd3-format'
   import * as d3 from 'd3-scale'
   import * as d3_sc from 'd3-scale-chromatic'
   import { timeFormat } from 'd3-time-format'
   import type { HTMLAttributes } from 'svelte/elements'
-  import type { D3InterpolateName } from '../colors'
+  import type { D3InterpolateName } from '../../../colors'
   import PortalSelect from './PortalSelect.svelte'
-  import { generate_arcsinh_ticks, scale_arcsinh } from './scales'
+  import { generate_arcsinh_ticks, scale_arcsinh } from '../scales'
   import type {
     AxisOption,
     ColorBarDataLoaderFn,
     ColorScaleOption,
     Orientation,
     ScaleType,
-  } from './types'
-  import { get_arcsinh_threshold, get_scale_type_name } from './types'
+  } from '../types'
+  import { get_arcsinh_threshold, get_scale_type_name } from '../types'
 
   let {
     title = $bindable(),
@@ -103,11 +103,11 @@
     // If ticks are secondary (top), default label to bottom
     if (orientation === `horizontal`) {
       return tick_side === `primary` ? `top` : `bottom`
-    } else { // orientation === `vertical`
+    } // orientation === `vertical`
       // If ticks are primary (right), default label to left
       // If ticks are secondary (left), default label to right
       return tick_side === `primary` ? `left` : `right`
-    }
+
   })
 
   // Number of ticks to generate
@@ -200,7 +200,7 @@
 
         const power_of_10_ticks: number[] = []
         for (let exp = start_exp; exp <= end_exp; exp++) {
-          power_of_10_ticks.push(Math.pow(10, exp))
+          power_of_10_ticks.push(10 ** exp)
         }
 
         // Ensure domain endpoints are included if they are powers of 10 and missed by loop
@@ -225,27 +225,24 @@
         }
 
         return power_of_10_ticks
-      } else {
-        // Generate exactly n_ticks manually for log scale if not snapping
-        const log_min = Math.log10(scale_min)
-        const log_max = Math.log10(scale_max)
-        return [...Array(n_ticks).keys()].map((idx) => {
-          const fraction = idx / (n_ticks - 1)
-          const log_val = log_min + fraction * (log_max - log_min)
-          return Math.pow(10, log_val)
-        })
-      }
-    } else {
-      // Use D3's default nice ticks for linear scale
-      if (snap_ticks) return scale.ticks(n_ticks)
-      else {
-        // Generate exactly n_ticks evenly spaced linear ticks
-        return [...Array(n_ticks).keys()].map((idx) => {
-          const fraction = idx / (n_ticks - 1)
-          return scale_min + fraction * (scale_max - scale_min)
-        })
       }
+      // Generate exactly n_ticks manually for log scale if not snapping
+      const log_min = Math.log10(scale_min)
+      const log_max = Math.log10(scale_max)
+      return [...Array(n_ticks).keys()].map((idx) => {
+        const fraction = idx / (n_ticks - 1)
+        const log_val = log_min + fraction * (log_max - log_min)
+        return 10 ** log_val
+      })
     }
+    // Use D3's default nice ticks for linear scale
+    if (snap_ticks) return scale.ticks(n_ticks)
+    // Generate exactly n_ticks evenly spaced linear ticks
+    return [...Array(n_ticks).keys()].map((idx) => {
+      const fraction = idx / (n_ticks - 1)
+      return scale_min + fraction * (scale_max - scale_min)
+    })
+
   })
 
   // Update nice_range binding when snapping ticks
@@ -380,7 +377,7 @@
       if (use_log_interp) {
         data_value = log_span === 0
           ? adjusted_min_ramp
-          : Math.pow(10, log_min + fraction * log_span)
+          : 10 ** (log_min + fraction * log_span)
       } else if (type_name === `arcsinh`) {
         data_value = asinh_span === 0
           ? min_ramp_domain
@@ -644,6 +641,12 @@
     display: var(--cbar-label-display);
     align-items: center;
     justify-content: center;
+    /* blur-only (no tint): invisible over uniform bg, smears busy bg to keep title readable */
+    background: var(--cbar-label-bg, transparent);
+    backdrop-filter: var(--cbar-label-backdrop-filter, blur(4px));
+    border-radius: var(--cbar-label-border-radius, var(--border-radius, 3pt));
+    /* keep title selectable/copyable */
+    user-select: text;
   }
   span.tick-label {
     position: absolute;

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

@@ -1,5 +1,5 @@
 import type { HTMLAttributes } from 'svelte/elements';
-import type { AxisOption, ColorBarDataLoaderFn, ColorScaleOption, Orientation, ScaleType } from './types';
+import type { AxisOption, ColorBarDataLoaderFn, ColorScaleOption, Orientation, ScaleType } from '../types';
 type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     title?: string;
     color_scale?: ((x: number) => string) | string | null;
@@ -26,6 +26,6 @@ type $$ComponentProps = HTMLAttributes<HTMLDivElement> & {
     selected_color_scale_key?: string;
     on_color_scale_change?: (key: string) => void;
 };
-declare const ColorBar: import("svelte").Component<$$ComponentProps, {}, "title" | "color_scale" | "range" | "tick_labels" | "nice_range" | "selected_property_key" | "selected_color_scale_key">;
+declare const ColorBar: import("svelte").Component<$$ComponentProps, {}, "title" | "range" | "color_scale" | "tick_labels" | "nice_range" | "selected_property_key" | "selected_color_scale_key">;
 type ColorBar = ReturnType<typeof ColorBar>;
 export default ColorBar;

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

@@ -1,9 +1,9 @@
 <script lang="ts">
-  import { ColorBar } from './'
+  import { ColorBar } from '../..'
   import * as d3_sc from 'd3-scale-chromatic'
   import type { ComponentProps } from 'svelte'
   import Select from 'svelte-multiselect'
-  import type { D3InterpolateName } from '../colors'
+  import type { D3InterpolateName } from '../../../colors'
 
   let {
     options = Object.keys(d3_sc).filter((key) =>
@@ -28,6 +28,7 @@
 <Select
   {options}
   maxSelect={1}
+  maxOptions={options.length}
   {minSelect}
   bind:value
   bind:selected
@@ -47,7 +48,7 @@
       tick_labels={0}
       title_side="left"
       wrapper_style="width: 100%;"
-      title_style="width: 6em; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; text-align: left;"
+      title_style="width: 6em; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; text-align: left; font-size: 0.9rem;"
       {...colorbar}
     />
   {/snippet}

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

@@ -1,7 +1,7 @@
-import { ColorBar } from './';
+import { ColorBar } from '../..';
 import type { ComponentProps } from 'svelte';
 import Select from 'svelte-multiselect';
-import type { D3InterpolateName } from '../colors';
+import type { D3InterpolateName } from '../../../colors';
 type $$ComponentProps = Omit<ComponentProps<typeof Select>, `options`> & {
     options?: D3InterpolateName[];
     value?: D3InterpolateName;

package/dist/plot/core/components/ControlPane.svelte

@@ -0,0 +1,46 @@
+<script lang="ts">
+  // Shared draggable controls-pane shell (gear toggle + settings pane) used by plot/diagram
+  // controls components. Centralizes the toggle/pane styling and the `*-controls-toggle` /
+  // `*-controls-pane` class convention so it lives in one place instead of being re-typed in
+  // every *Controls component (PlotControls, SankeyControls, ...).
+  import { DraggablePane } from '../../../overlays'
+  import type { Snippet } from 'svelte'
+  import type { HTMLAttributes } from 'svelte/elements'
+
+  let {
+    controls_open = $bindable(false),
+    controls_class = `plot`,
+    title = controls_class || `plot`,
+    toggle_props = {},
+    pane_props = {},
+    children,
+  }: {
+    controls_open?: boolean
+    controls_class?: string // class prefix -> `${controls_class}-controls-{toggle,pane}`
+    title?: string // toggle button title text ("Open <title> controls")
+    toggle_props?: HTMLAttributes<HTMLButtonElement>
+    pane_props?: HTMLAttributes<HTMLDivElement>
+    children?: Snippet
+  } = $props()
+</script>
+
+<DraggablePane
+  bind:show={controls_open}
+  closed_icon="Settings"
+  open_icon="Cross"
+  toggle_props={{
+    title: `${controls_open ? `Close` : `Open`} ${title} controls`,
+    ...toggle_props,
+    class: `${controls_class}-controls-toggle ${toggle_props?.class ?? ``}`,
+    style:
+      `position: absolute; top: var(--ctrl-btn-top, 5pt); right: var(--ctrl-btn-right, 1ex);` +
+      (toggle_props?.style ?? ``),
+  }}
+  pane_props={{
+    ...pane_props,
+    class: `${controls_class}-controls-pane ${pane_props?.class ?? ``}`,
+    style: `--pane-padding: 12px; --pane-gap: 4px; ${pane_props?.style ?? ``}`,
+  }}
+>
+  {@render children?.()}
+</DraggablePane>

package/dist/plot/core/components/ControlPane.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = {
+    controls_open?: boolean;
+    controls_class?: string;
+    title?: string;
+    toggle_props?: HTMLAttributes<HTMLButtonElement>;
+    pane_props?: HTMLAttributes<HTMLDivElement>;
+    children?: Snippet;
+};
+declare const ControlPane: import("svelte").Component<$$ComponentProps, {}, "controls_open">;
+type ControlPane = ReturnType<typeof ControlPane>;
+export default ControlPane;

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

@@ -8,7 +8,8 @@
     FillGradient,
     FillHandlerEvent,
     FillRegion,
-  } from './types'
+  } from '../types'
+  import { unique_id } from '../utils'
 
   let {
     region,
@@ -35,14 +36,17 @@
   } = $props()
 
   // Stable instance ID for gradient uniqueness (generated once per component instance)
-  const instance_id = crypto.randomUUID().slice(0, 8)
+  const instance_id = unique_id()
   let gradient_id = $derived(
     `fill-gradient-${region.id ?? region_idx}-${instance_id}`,
   )
 
+  // On hover (without an explicit hover_style), noticeably raise opacity. A faint fill (e.g. a
+  // low-alpha rgba color at the default 0.3 fill-opacity) is otherwise nearly invisible, so a mere
+  // brightness filter reads as "no change". An explicit hover_style.fill_opacity always wins.
   let effective_opacity = $derived(
-    is_hovered && region.hover_style?.fill_opacity != null
-      ? region.hover_style.fill_opacity
+    is_hovered
+      ? region.hover_style?.fill_opacity ?? Math.min(1, (region.fill_opacity ?? 0.3) + 0.4)
       : region.fill_opacity ?? 0.3,
   )
   let effective_fill = $derived(
@@ -53,6 +57,8 @@
   let path_fill = $derived(
     typeof effective_fill === `object` ? `url(#${gradient_id})` : effective_fill,
   )
+  // outline drawn only on hover when the user opted in via hover_style.stroke
+  let hover_stroke = $derived(is_hovered ? region.hover_style?.stroke : undefined)
   let is_clickable = $derived(Boolean(on_click || region.on_click))
   let cursor_style = $derived(
     region.hover_style?.cursor ?? (is_clickable ? `pointer` : `default`),
@@ -205,11 +211,16 @@
     </defs>
   {/if}
 
-  <!-- Main fill path -->
+  <!-- Main fill path. On hover the opacity boost (effective_opacity) highlights the area. We do NOT
+       stroke by default: a fill-between region is one closed polygon, so stroking traces its whole
+       perimeter (both boundaries + the straight closing edges), which looks messy and doesn't follow
+       the visible area. Users can still opt into an outline via hover_style.stroke. -->
   <path
     d={tweened_path.current}
     fill={path_fill}
     fill-opacity={effective_opacity}
+    stroke={hover_stroke ?? `none`}
+    stroke-width={hover_stroke ? region.hover_style?.stroke_width ?? 1.5 : 0}
   />
 </g>
 
@@ -218,6 +229,6 @@
     transition: opacity 0.15s ease;
   }
   .fill-region.hovered {
-    filter: brightness(1.1);
+    filter: brightness(1.35) saturate(1.2);
   }
 </style>

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

@@ -1,5 +1,5 @@
 import { type TweenOptions } from 'svelte/motion';
-import type { FillHandlerEvent, FillRegion } from './types';
+import type { FillHandlerEvent, FillRegion } from '../types';
 type $$ComponentProps = {
     region: FillRegion;
     region_idx: number;

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

@@ -1,8 +1,8 @@
 <script lang="ts">
-  import Spinner from '../feedback/Spinner.svelte'
-  import { sanitize_html } from '../sanitize'
+  import Spinner from '../../../feedback/Spinner.svelte'
+  import { sanitize_html } from '../../../sanitize'
   import PortalSelect from './PortalSelect.svelte'
-  import type { AxisOption } from './types'
+  import type { AxisOption } from '../types'
 
   let {
     label = ``,

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

@@ -1,4 +1,4 @@
-import type { AxisOption } from './types';
+import type { AxisOption } from '../types';
 type $$ComponentProps = {
     label?: string;
     options?: AxisOption[];
@@ -9,6 +9,6 @@ type $$ComponentProps = {
     on_select?: (key: string) => void;
     [key: string]: unknown;
 };
-declare const InteractiveAxisLabel: import("svelte").Component<$$ComponentProps, {}, "color" | "selected_key" | "loading">;
+declare const InteractiveAxisLabel: import("svelte").Component<$$ComponentProps, {}, "color" | "loading" | "selected_key">;
 type InteractiveAxisLabel = ReturnType<typeof InteractiveAxisLabel>;
 export default InteractiveAxisLabel;