matterviz 0.4.1 → 0.4.3

package/dist/plot/treemap/Treemap.svelte.d.ts

@@ -0,0 +1,90 @@
+import type { D3InterpolateName } from '../../colors';
+import type { Vec2 } from '../../math';
+import type { BasePlotProps, LegendConfig, SunburstLabelText, SunburstSort, SunburstValueMode } from '..';
+import { ColorBar } from '..';
+import type { Rect, Sides } from '../core/layout';
+import type { PositionedArc } from '../sunburst/sunburst';
+import { type TreemapLabelFit, type TreemapLabelFormatter } from './labels';
+import type { TreemapNode, TreemapNodeHandlerProps } from './treemap';
+import type { ComponentProps, Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+import { type TweenOptions } from 'svelte/motion';
+declare function $$render<Metadata extends Record<string, unknown> = Record<string, unknown>>(): {
+    props: HTMLAttributes<HTMLDivElement> & Omit<BasePlotProps, "change"> & {
+        data?: TreemapNode<Metadata> | TreemapNode<Metadata>[];
+        value_mode?: SunburstValueMode;
+        sort?: SunburstSort;
+        level_lighten?: number;
+        min_fraction?: number;
+        other_label?: string;
+        max_depth?: number;
+        padding_inner?: number;
+        padding_top?: number;
+        padding_outer?: number;
+        show_labels?: boolean;
+        label_text?: SunburstLabelText;
+        label_formatter?: TreemapLabelFormatter<Metadata>;
+        label_fit?: TreemapLabelFit;
+        label_min_font_size?: number;
+        label_max_font_size?: number;
+        parent_label_font_size?: number;
+        zoom_on_click?: boolean;
+        zoom_root_id?: string | number | null;
+        show_breadcrumbs?: boolean;
+        color_values?: (rect: PositionedArc<Metadata>) => number | null;
+        color_scale?: D3InterpolateName;
+        color_range?: Vec2;
+        colorbar?: ComponentProps<typeof ColorBar> | null;
+        export_buttons?: boolean;
+        export_filename?: string;
+        tween?: Omit<TweenOptions<Rect[]>, `interpolate`>;
+        value_format?: string;
+        padding?: Sides;
+        legend?: LegendConfig | null;
+        show_legend?: boolean;
+        tooltip?: Snippet<[TreemapNodeHandlerProps<Metadata>]>;
+        cell_content?: Snippet<[{
+            arc: PositionedArc<Metadata>;
+            rect: Rect;
+        }]>;
+        change?: (data: TreemapNodeHandlerProps<Metadata> | null) => void;
+        on_node_click?: (data: TreemapNodeHandlerProps<Metadata> & {
+            event: MouseEvent | KeyboardEvent;
+        }) => void;
+        on_node_hover?: (data: (TreemapNodeHandlerProps<Metadata> & {
+            event: MouseEvent | FocusEvent;
+        }) | null) => void;
+        on_zoom?: (data: {
+            root: TreemapNodeHandlerProps<Metadata> | null;
+        }) => void;
+        header_controls?: Snippet<[{
+            height: number;
+            width: number;
+            fullscreen: boolean;
+        }]>;
+        controls_extra?: Snippet<[{
+            zoom_root_id: string | number | null;
+        }]>;
+    };
+    exports: {};
+    bindings: "show_controls" | "data" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "padding_inner" | "padding_top" | "padding_outer" | "value_mode" | "max_depth" | "min_fraction" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<Metadata extends Record<string, unknown> = Record<string, unknown>> {
+    props(): ReturnType<typeof $$render<Metadata>>['props'];
+    events(): ReturnType<typeof $$render<Metadata>>['events'];
+    slots(): ReturnType<typeof $$render<Metadata>>['slots'];
+    bindings(): "show_controls" | "data" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "padding_inner" | "padding_top" | "padding_outer" | "value_mode" | "max_depth" | "min_fraction" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <Metadata extends Record<string, unknown> = Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<Metadata>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<Metadata>['props']>, ReturnType<__sveltets_Render<Metadata>['events']>, ReturnType<__sveltets_Render<Metadata>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<Metadata>['bindings']>;
+    } & ReturnType<__sveltets_Render<Metadata>['exports']>;
+    <Metadata extends Record<string, unknown> = Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<Metadata>['props']> & {}): ReturnType<__sveltets_Render<Metadata>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Treemap: $$IsomorphicComponent;
+type Treemap<Metadata extends Record<string, unknown> = Record<string, unknown>> = InstanceType<typeof Treemap<Metadata>>;
+export default Treemap;

package/dist/plot/treemap/index.d.ts

@@ -0,0 +1,4 @@
+export * from './treemap';
+export type { TreemapLabelFit, TreemapLabelFormatter, TreemapLabelLine } from './labels';
+export { default as Treemap } from './Treemap.svelte';
+export { default as TreemapControls } from '../core/components/HierarchyControls.svelte';

package/dist/plot/treemap/index.js

@@ -0,0 +1,4 @@
+export * from './treemap';
+export { default as Treemap } from './Treemap.svelte';
+// Shared with Sunburst; pass chart="treemap"
+export { default as TreemapControls } from '../core/components/HierarchyControls.svelte';

package/dist/plot/treemap/labels.d.ts

@@ -0,0 +1,38 @@
+import type { Rect } from '../core/layout';
+import type { TreemapArc } from './treemap';
+export type TreemapLabelFit = `hide` | `shrink` | `clip`;
+export interface TreemapLabelLine {
+    text: string;
+    class?: string;
+    font_scale?: number;
+    font_weight?: string | number;
+    opacity?: number;
+    fill?: string;
+}
+type TreemapLabelContent = string | TreemapLabelLine | null | undefined;
+export type TreemapLabelFormatter<Metadata extends Record<string, unknown> = Record<string, unknown>> = (arc: TreemapArc<Metadata>) => TreemapLabelContent | readonly TreemapLabelContent[];
+export interface TreemapLabelPlacement {
+    x: number;
+    lines: (TreemapLabelLine & {
+        y: number;
+    })[];
+    font_size: number;
+    header: boolean;
+    dominant_baseline: `central`;
+    transform?: string;
+}
+interface TreemapLabelPlacementOptions {
+    rect: Rect;
+    lines: readonly TreemapLabelLine[];
+    header: boolean;
+    fit: TreemapLabelFit;
+    min_font_size: number;
+    max_font_size: number;
+    padding_top: number;
+    margin: number;
+    measure_line: (line: TreemapLabelLine, font_size: number) => number;
+}
+export declare const safe_font_size: (font_size: number, fallback: number) => number;
+export declare function normalize_treemap_label_lines(content: ReturnType<TreemapLabelFormatter>): TreemapLabelLine[];
+export declare function place_treemap_label({ rect, lines, header, fit, min_font_size, max_font_size, padding_top, margin, measure_line, }: TreemapLabelPlacementOptions): TreemapLabelPlacement | null;
+export {};

package/dist/plot/treemap/labels.js

@@ -0,0 +1,80 @@
+const LINE_HEIGHT = 1.1;
+const MIN_FONT_SIZE = 0.5;
+const MIN_FONT_SCALE = 0.05;
+// Coerce a user-provided font size to a usable px value (0.5px floor guards
+// against zero/negative sizes; non-finite input falls back)
+export const safe_font_size = (font_size, fallback) => Number.isFinite(font_size) ? Math.max(MIN_FONT_SIZE, font_size) : fallback;
+export function normalize_treemap_label_lines(content) {
+    if (content == null)
+        return [];
+    const lines = Array.isArray(content) ? content : [content];
+    return lines.flatMap((line) => {
+        const normalized = typeof line === `string` ? { text: line } : line;
+        return normalized?.text ? [{ ...normalized }] : [];
+    });
+}
+const line_scale = (line) => Number.isFinite(line.font_scale) ? Math.max(MIN_FONT_SCALE, line.font_scale ?? 1) : 1;
+function block_metrics(lines, font_size, measure_line) {
+    let width = 0;
+    let height = 0;
+    for (const line of lines) {
+        const line_font_size = font_size * line_scale(line);
+        width = Math.max(width, measure_line(line, line_font_size));
+        height += line_font_size * LINE_HEIGHT;
+    }
+    return { width, height };
+}
+export function place_treemap_label({ rect, lines, header, fit, min_font_size, max_font_size, padding_top, margin, measure_line, }) {
+    if (lines.length === 0)
+        return null;
+    const safe_max_font_size = safe_font_size(max_font_size, 11);
+    const safe_min_font_size = Math.min(safe_max_font_size, safe_font_size(min_font_size, MIN_FONT_SIZE));
+    const header_height = Math.min(rect.height, padding_top);
+    const available_width = Math.max(0, rect.width - 2 * margin);
+    const label_height = header ? header_height : rect.height;
+    const available_height = Math.max(0, label_height - 2 * (header ? 1 : margin));
+    // Single guard for all degenerate geometry (zero/negative/NaN rects, missing
+    // header strips, margin-swallowed slivers): negated > 0 so NaN also bails
+    // instead of emitting NaN SVG coordinates, same idiom as tile_rects.
+    if (!(available_width > 0) || !(available_height > 0))
+        return null;
+    const max_metrics = block_metrics(lines, safe_max_font_size, measure_line);
+    const fit_ratio = (block_width, block_height) => block_width > 0 && block_height > 0
+        ? Math.min(1, available_width / block_width, available_height / block_height)
+        : 0;
+    const horizontal_ratio = fit_ratio(max_metrics.width, max_metrics.height);
+    // rotated 90°: the block's width runs along the cell's height (swapped args)
+    const vertical_ratio = header ? 0 : fit_ratio(max_metrics.height, max_metrics.width);
+    const rotated = vertical_ratio > horizontal_ratio;
+    const best_ratio = Math.max(horizontal_ratio, vertical_ratio);
+    if (fit === `hide` && best_ratio < 1)
+        return null;
+    const font_size = fit === `shrink`
+        ? Math.max(safe_min_font_size, safe_max_font_size * best_ratio)
+        : safe_max_font_size;
+    // text metrics scale linearly with font size, so the block height at the
+    // final size derives from the max-size measurement — no re-measuring (which
+    // would miss the width cache on every frame of a zoom tween in shrink mode,
+    // since the fitted size varies continuously with the animated rect)
+    const block_height = max_metrics.height * (font_size / safe_max_font_size);
+    const center_x = rect.x + rect.width / 2;
+    const center_y = rect.y + label_height / 2;
+    const x = header ? rect.x + margin : center_x;
+    let line_top = center_y - block_height / 2;
+    const placed_lines = lines.map((line) => {
+        const font_scale = line_scale(line);
+        const line_height = font_size * font_scale * LINE_HEIGHT;
+        line_top += line_height / 2;
+        const y = line_top;
+        line_top += line_height / 2;
+        return { ...line, font_scale, y };
+    });
+    return {
+        x,
+        lines: placed_lines,
+        font_size,
+        header,
+        dominant_baseline: `central`,
+        ...(rotated ? { transform: `rotate(-90, ${center_x}, ${center_y})` } : {}),
+    };
+}

package/dist/plot/treemap/treemap.d.ts

@@ -0,0 +1,28 @@
+import type { Rect } from '../core/layout';
+import type { PositionedArc, SunburstLayoutOptions, SunburstNode, SunburstNodeHandlerProps, SunburstSort } from '../sunburst/sunburst';
+export type TreemapNode<Metadata = Record<string, unknown>> = SunburstNode<Metadata>;
+export type TreemapArc<Metadata = Record<string, unknown>> = PositionedArc<Metadata>;
+export type TreemapNodeHandlerProps<Metadata = Record<string, unknown>> = SunburstNodeHandlerProps<Metadata>;
+export interface TreemapLayoutOptions extends Omit<SunburstLayoutOptions, `sort`> {
+    sort?: SunburstSort;
+}
+export interface TilePadding {
+    padding_inner: number;
+    padding_top: number;
+    padding_outer: number;
+}
+export declare function tile_rects<Metadata>(arcs: readonly PositionedArc<Metadata>[], root_idx: number, size: {
+    width: number;
+    height: number;
+}, pad: TilePadding): Rect[];
+export declare function lerp_rects(prev: readonly Rect[], next: readonly Rect[], t: number): Rect[];
+export interface TreemapLayoutResult<Metadata = Record<string, unknown>> {
+    arcs: TreemapArc<Metadata>[];
+    rects: Rect[];
+    root: TreemapArc<Metadata> | null;
+    max_depth: number;
+}
+export declare function compute_treemap_layout<Metadata = Record<string, unknown>>(data: TreemapNode<Metadata> | TreemapNode<Metadata>[], size: {
+    width: number;
+    height: number;
+}, opts?: TreemapLayoutOptions & Partial<TilePadding>): TreemapLayoutResult<Metadata>;

package/dist/plot/treemap/treemap.js

@@ -0,0 +1,102 @@
+// Layout helpers for Treemap charts. All tree semantics (value modes, sorting,
+// 'Other' bucketing, color inheritance, stable ids, pre-order indexing) are
+// delegated to compute_sunburst_layout — a treemap is the same hierarchy with
+// squarified pixel rects instead of polar partition coordinates, so the two
+// charts share data builders (sunburst_from_paths, chem_sys_sunburst_data, …)
+// and value semantics (plotly branchvalues) by construction.
+import { hierarchy, treemap, treemapSquarify } from 'd3-hierarchy';
+import { compute_sunburst_layout } from '../sunburst/sunburst';
+import { DEFAULTS } from '../../settings';
+// Fresh object per call: returned rect arrays hand these to consumers, and a
+// shared constant would let mutating one zero rect corrupt every other one
+const zero_rect = () => ({ x: 0, y: 0, width: 0, height: 0 });
+// Squarify the subtree under arcs[root_idx] into pixel rects filling `size`.
+// Returns an array aligned with `arcs` by node_idx (nodes outside the subtree
+// get zero rects). Separate from tree-semantics so zooming re-tiles the new
+// root's subtree to the full viewport (plotly behavior) — unlike the sunburst's
+// size-independent partition, squarified tiling depends on the target aspect
+// ratio, so projecting one fixed layout through a zoom window would distort
+// cells and scale up the fixed-px header strips.
+export function tile_rects(arcs, root_idx, size, pad) {
+    const rects = arcs.map(zero_rect);
+    const root_arc = arcs[root_idx];
+    if (!root_arc || !(size.width > 0) || !(size.height > 0))
+        return rects;
+    // Rebuild the (already value-resolved, sorted and bucketed) subtree from the
+    // flat pre-order arcs: children of arc N are the top-level subtree ranges in
+    // (N, N.subtree_end].
+    const children_of = (arc) => {
+        const kids = [];
+        for (let idx = arc.node_idx + 1; idx <= arc.subtree_end; idx = arcs[idx].subtree_end + 1) {
+            kids.push(arcs[idx]);
+        }
+        return kids;
+    };
+    const root = hierarchy(root_arc, children_of);
+    // Values are assigned manually (the documented d3 way to bypass .sum()) so all
+    // three value modes carry over — with 'total', children summing to less than
+    // their parent leave unfilled space in the parent cell, matching plotly.
+    // Non-finite/negative values would make d3's tiling emit NaN/out-of-bounds
+    // rects; coerce them to zero-size instead of corrupting the whole chart.
+    root.each((node) => {
+        const { value } = node.data;
+        node.value = Number.isFinite(value) && value >= 0 ? value : 0;
+    });
+    const tiled = treemap()
+        .tile(treemapSquarify)
+        .size([size.width, size.height])
+        .paddingInner(pad.padding_inner)
+        // inset children within branch cells below the tiling root (the root fills
+        // the viewport and is labeled by breadcrumbs, not a frame + header) …
+        .paddingOuter((node) => (node.depth > 0 ? pad.padding_outer : 0))
+        // … with the top inset enlarged into the label header strip. paddingTop is
+        // applied after paddingOuter, overriding its top component.
+        .paddingTop((node) => node.depth > 0 && node.children ? Math.max(pad.padding_top, pad.padding_outer) : 0)(root);
+    // Clamp to the tiling area: with value_mode 'total', children exceeding their
+    // parent's value overflow the parent rect (d3 scales children by parent value;
+    // compute_sunburst_layout warns). Clamping keeps overflow inside the chart,
+    // mirroring the sunburst's clamp01 window projection.
+    const clamp_x = (val) => Math.min(Math.max(val, 0), size.width);
+    const clamp_y = (val) => Math.min(Math.max(val, 0), size.height);
+    tiled.each((node) => {
+        const x = clamp_x(node.x0);
+        const y = clamp_y(node.y0);
+        rects[node.data.node_idx] = {
+            x,
+            y,
+            width: Math.max(0, clamp_x(node.x1) - x),
+            height: Math.max(0, clamp_y(node.y1) - y),
+        };
+    });
+    return rects;
+}
+// Interpolate between two tilings (zoom animation). Rects are aligned by
+// node_idx; frames allocate one array but reuse rect objects at t = 0/1.
+export function lerp_rects(prev, next, t) {
+    if (t >= 1 || prev.length !== next.length)
+        return next;
+    if (t <= 0)
+        return prev;
+    return next.map((to, idx) => {
+        const from = prev[idx];
+        return {
+            x: from.x + (to.x - from.x) * t,
+            y: from.y + (to.y - from.y) * t,
+            width: from.width + (to.width - from.width) * t,
+            height: from.height + (to.height - from.height) * t,
+        };
+    });
+}
+// One-shot semantic layout + root tiling (tests and non-zooming callers; the
+// component calls compute_sunburst_layout and tile_rects separately so zoom
+// re-tiles without recomputing tree semantics).
+export function compute_treemap_layout(data, size, opts = {}) {
+    // padding fallbacks derive from DEFAULTS.treemap to prevent drift with the component
+    const { padding_inner = DEFAULTS.treemap.padding_inner, padding_top = DEFAULTS.treemap.padding_top, padding_outer = DEFAULTS.treemap.padding_outer, 
+    // descending (matching the Treemap component): squarified tiling reads best
+    // with the largest cell top-left and smallest bottom-right
+    sort = `descending`, ...tree_opts } = opts;
+    const { arcs, root, max_depth } = compute_sunburst_layout(data, { sort, ...tree_opts });
+    const rects = tile_rects(arcs, 0, size, { padding_inner, padding_top, padding_outer });
+    return { arcs, rects, root, max_depth };
+}

package/dist/rdf/RdfPlot.svelte

@@ -21,7 +21,7 @@
     y_axis = {},
     cutoff = 15,
     n_bins = 75,
-    pbc = [true, true, true],
+    pbc,
     enable_drop = false,
     on_file_drop,
     loading = $bindable(false),
@@ -56,9 +56,7 @@
 
   const compute_and_add = (content: string | ArrayBuffer, filename: string) => {
     try {
-      const text = content instanceof ArrayBuffer
-        ? new TextDecoder().decode(content)
-        : content
+      const text = content instanceof ArrayBuffer ? new TextDecoder().decode(content) : content
       const parsed_struct = parse_any_structure(text, filename)
       if (is_crystal(parsed_struct)) {
         drag_dropped = [...drag_dropped, parsed_struct]
@@ -66,16 +64,13 @@
         error_msg = `Crystal has no lattice or sites; cannot compute RDF`
       }
     } catch (exc) {
-      error_msg = `Failed to process structure: ${
-        to_error(exc).message
-      }`
+      error_msg = `Failed to process structure: ${to_error(exc).message}`
     }
   }
 
   const handle_drop = create_file_drop_handler({
     allow: () => enable_drop,
-    on_drop: (content, filename) =>
-      (on_file_drop || compute_and_add)(content, filename),
+    on_drop: (content, filename) => (on_file_drop || compute_and_add)(content, filename),
     on_error: (msg) => {
       error_msg = msg
     },
@@ -85,57 +80,43 @@
     },
   })
 
-  function handle_dragover(ev: DragEvent) {
-    ev.preventDefault()
-    if (ev.dataTransfer) ev.dataTransfer.dropEffect = `copy`
+  function handle_dragover(event: DragEvent) {
+    event.preventDefault()
+    if (event.dataTransfer) event.dataTransfer.dropEffect = `copy`
     dragging = true
   }
 
   const entries = $derived.by(() => {
-    const result: RdfEntry[] = []
-
-    // Add patterns
-    if (patterns) {
-      if (Array.isArray(patterns)) result.push(...patterns)
-      else result.push(patterns)
-    }
-
-    // Add structures
-    const struct_list: { struct: Crystal; label: string }[] = []
-    if (structures) {
-      if (Array.isArray(structures)) {
-        structures.forEach((struct, idx) =>
-          struct_list.push({
-            struct,
-            label: format_structure_label(struct, `Crystal ${idx + 1}`),
-          })
-        )
-      } else if (is_crystal(structures)) {
-        struct_list.push({
-          struct: structures,
-          label: format_structure_label(structures, ``),
-        })
-      } else {
-        Object.entries(structures).forEach(([label, struct]) =>
-          struct_list.push({ struct, label: format_structure_label(struct, label) })
-        )
-      }
-    }
-    drag_dropped.forEach((struct, idx) =>
-      struct_list.push({
-        struct,
-        label: format_structure_label(struct, `Dropped ${idx + 1}`),
-      })
-    )
+    const result: RdfEntry[] = patterns
+      ? Array.isArray(patterns)
+        ? [...patterns]
+        : [patterns]
+      : []
+
+    // Normalize structures prop (single, array, or dict) plus dropped files to labeled list
+    const struct_list = [
+      ...(!structures
+        ? []
+        : Array.isArray(structures)
+          ? structures.map((struct, idx) => ({ struct, base: `Crystal ${idx + 1}` }))
+          : is_crystal(structures)
+            ? [{ struct: structures, base: `` }]
+            : Object.entries(structures).map(([base, struct]) => ({ struct, base }))),
+      ...drag_dropped.map((struct, idx) => ({ struct, base: `Dropped ${idx + 1}` })),
+    ].map(({ struct, base }) => ({ struct, label: format_structure_label(struct, base) }))
 
     for (const { struct, label } of struct_list) {
       if (mode === `element_pairs`) {
         const pairs = calculate_all_pair_rdfs(struct, { cutoff, n_bins, pbc })
-        result.push(...pairs.map((pair) => ({
-          label: pair.element_pair ? `${pair.element_pair[0]}-${pair.element_pair[1]}` : label,
-          legend_group: label, // Group by structure name for multi-structure plots
-          pattern: pair,
-        })))
+        result.push(
+          ...pairs.map((pair) => ({
+            label: pair.element_pair
+              ? `${pair.element_pair[0]}-${pair.element_pair[1]}`
+              : label,
+            legend_group: label, // Group by structure name for multi-structure plots
+            pattern: pair,
+          })),
+        )
       } else {
         const pattern = calculate_rdf(struct, { cutoff, n_bins, pbc })
         result.push({ label, pattern })
@@ -146,7 +127,6 @@
 
   const max_r = $derived(Math.max(...entries.flatMap((entry) => entry.pattern.r), 0))
   const max_g = $derived(Math.max(1.2, ...entries.flatMap((entry) => entry.pattern.g_r)))
-
   const series = $derived<DataSeries[]>(
     entries.map((ent, idx) => ({
       x: ent.pattern.r,
@@ -182,8 +162,8 @@
   >
     <StatusMessage
       message={enable_drop
-      ? `Drag and drop structure files here to visualize RDFs`
-      : `No RDF data to display`}
+        ? `Drag and drop structure files here to visualize RDFs`
+        : `No RDF data to display`}
       style="border: none"
     />
   </div>
@@ -194,7 +174,7 @@
     x_axis={{ label: `r (Å)`, range: [0, max_r], ...x_axis }}
     y_axis={{ label: `g(r)`, range: [0, max_g * 1.05], ...y_axis }}
     styles={{ show_lines: true, show_points: false }}
-    class="{rest.class ?? ``} {dragging ? `dragging` : ``}"
+    class={[rest.class, dragging && `dragging`]}
     style={rest.style ?? `height: 400px;`}
     ondragover={enable_drop ? handle_dragover : undefined}
     ondragleave={enable_drop ? () => (dragging = false) : undefined}
@@ -207,9 +187,7 @@
           {@const [x1, x2] = [pad.l, width - pad.r]}
           {@const [x, y] = [width - pad.r - 5, y1 - 5]}
           <line {x1} {x2} {y1} y2={y1} stroke="gray" stroke-dasharray="4" opacity="0.5" />
-          <text {x} {y} text-anchor="end" fill="gray" font-size="0.8em">
-            g(r) = 1
-          </text>
+          <text {x} {y} text-anchor="end" fill="gray" font-size="0.8em"> g(r) = 1 </text>
         {/if}
       {/if}
     {/snippet}

package/dist/rdf/RdfPlot.svelte.d.ts

@@ -22,6 +22,6 @@ type $$ComponentProps = {
     drag_dropped?: Crystal[];
     dragging?: boolean;
 } & ComponentProps<typeof ScatterPlot>;
-declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "loading" | "dragging" | "error_msg" | "drag_dropped">;
+declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "dragging" | "loading" | "error_msg" | "drag_dropped">;
 type RdfPlot = ReturnType<typeof RdfPlot>;
 export default RdfPlot;