matterviz 0.4.0 → 0.4.2

package/dist/plot/sunburst/Sunburst.svelte.d.ts

@@ -1,4 +1,5 @@
 import type { D3InterpolateName } from '../../colors';
+import { type Vec2 } from '../../math';
 import type { BasePlotProps, LegendConfig, SunburstLabelRotation, SunburstLabelText, SunburstNode, SunburstNodeHandlerProps, SunburstShape, SunburstSort, SunburstValueMode } from '..';
 import { ColorBar } from '..';
 import type { Sides } from '../core/layout';
@@ -26,7 +27,7 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         show_breadcrumbs?: boolean;
         color_values?: (arc: PositionedArc<Metadata>) => number | null;
         color_scale?: D3InterpolateName;
-        color_range?: [number, number];
+        color_range?: Vec2;
         colorbar?: ComponentProps<typeof ColorBar> | null;
         export_buttons?: boolean;
         export_filename?: string;
@@ -73,7 +74,7 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         }]>;
     };
     exports: {};
-    bindings: "data" | "show_controls" | "fullscreen" | "hovered" | "controls_open" | "value_mode" | "min_fraction" | "show_labels" | "shape" | "max_depth" | "inner_radius" | "pad_angle" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
+    bindings: "show_controls" | "data" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "shape" | "inner_radius" | "pad_angle" | "label_rotation" | "value_mode" | "max_depth" | "min_fraction" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
     slots: {};
     events: {};
 };
@@ -81,7 +82,7 @@ declare class __sveltets_Render<Metadata extends Record<string, unknown> = Recor
     props(): ReturnType<typeof $$render<Metadata>>['props'];
     events(): ReturnType<typeof $$render<Metadata>>['events'];
     slots(): ReturnType<typeof $$render<Metadata>>['slots'];
-    bindings(): "data" | "show_controls" | "fullscreen" | "hovered" | "controls_open" | "value_mode" | "min_fraction" | "show_labels" | "shape" | "max_depth" | "inner_radius" | "pad_angle" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
+    bindings(): "show_controls" | "data" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "shape" | "inner_radius" | "pad_angle" | "label_rotation" | "value_mode" | "max_depth" | "min_fraction" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
     exports(): {};
 }
 interface $$IsomorphicComponent {

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

@@ -1,4 +1,4 @@
 export * from './render';
 export * from './sunburst';
 export { default as Sunburst } from './Sunburst.svelte';
-export { default as SunburstControls } from './SunburstControls.svelte';
+export { default as SunburstControls } from '../core/components/HierarchyControls.svelte';

package/dist/plot/sunburst/index.js

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

package/dist/plot/sunburst/render.d.ts

@@ -30,5 +30,5 @@ export declare function arc_label_transform(d: {
     a1: number;
     r0: number;
     r1: number;
-}, text_w: number, // rendered text width in px
-shape: SunburstShape, rotation: SunburstLabelRotation): string | null;
+}, text_w: number, // rendered text width in px (pre-multiplied by font_scale)
+shape: SunburstShape, rotation: SunburstLabelRotation, max_radius?: number, font_scale?: number): string | null;

package/dist/plot/sunburst/render.js

@@ -3,8 +3,8 @@
 // Pure functions (no component state) so the trickiest geometry stays unit-testable;
 // Sunburst.svelte wires them to reactive state and the DOM.
 import { to_degrees } from '../../math';
+import { clamp01 } from '../../utils';
 const TWO_PI = 2 * Math.PI;
-const clamp01 = (val) => Math.min(1, Math.max(0, val));
 // Project all arcs through a view window into screen space. The two shapes share the
 // same window-mapping math, only the scale constants differ. Returns `all` (indexed
 // by node_idx, for event lookups) and `visible` (collapsed arcs pruned) from one pass.
@@ -77,11 +77,23 @@ export function arrow_nav_target(arcs, is_visible, current_idx, key) {
 // in 'auto' mode); null = doesn't fit, hide the label. Angles are clockwise from 12
 // o'clock, so the point at (a, r) is (sin(a)*r, -cos(a)*r). Icicle cells label
 // horizontally, or rotated 90° when too narrow but tall enough to fit upright.
-export function arc_label_transform(d, text_w, // rendered text width in px
-shape, rotation) {
+// `max_radius` (chart outer radius) additionally keeps straight-line labels inside
+// the chart circle: tangential text on a wide arc has plenty of arc length but
+// renders as a straight tangent line whose ends would otherwise shoot past the
+// plot border.
+// `font_scale` < 1 relaxes the fit for downscaled text: callers pass the already
+// scaled text width, and the one-line-height across-requirement shrinks with it.
+export function arc_label_transform(d, text_w, // rendered text width in px (pre-multiplied by font_scale)
+shape, rotation, max_radius, font_scale = 1) {
     // Text fits when it's shorter than the space along its reading direction and the
     // cell is at least one line-height across
-    const fits = (along, across) => text_w <= along - 6 && across >= 12;
+    const fits = (along, across) => text_w <= along - 6 && across >= 12 * font_scale;
+    // Farthest endpoint of a straight label centered `center_dist` from the chart
+    // center: text_w/2 perpendicular to the radius (tangential text, exact) plus an
+    // optional component along it (horizontal text at 3/9 o'clock reads radially)
+    const inside_chart = (center_dist, along_radius = 0) => max_radius === undefined ||
+        Math.sqrt(center_dist ** 2 + (text_w / 2) ** 2 + text_w * center_dist * along_radius) <=
+            max_radius;
     if (shape === `icicle`) {
         const cell_w = d.a1 - d.a0;
         const cell_h = d.r1 - d.r0;
@@ -99,24 +111,37 @@ shape, rotation) {
     const mid_r = (d.r0 + d.r1) / 2;
     const angular_px = (d.a1 - d.a0) * mid_r; // arc length at mid radius
     const radial_px = d.r1 - d.r0;
-    const mode = rotation === `auto` ? (radial_px >= angular_px ? `radial` : `tangential`) : rotation;
-    if (mode === `horizontal`) {
-        if (!fits(Math.max(angular_px, radial_px), Math.min(angular_px, radial_px))) {
-            return null;
+    // 'auto' prefers the roomier orientation but falls back to the other one:
+    // a wide-but-shallow arc whose text overflows the tangent line may still
+    // fit reading radially (and vice versa), which beats hiding the label.
+    const modes = rotation === `auto`
+        ? radial_px >= angular_px
+            ? [`radial`, `tangential`]
+            : [`tangential`, `radial`]
+        : [rotation];
+    for (const mode of modes) {
+        if (mode === `horizontal`) {
+            if (!fits(Math.max(angular_px, radial_px), Math.min(angular_px, radial_px))) {
+                continue;
+            }
+            if (!inside_chart(mid_r, Math.abs(Math.sin(mid_a))))
+                continue;
+            return `translate(${Math.sin(mid_a) * mid_r}, ${-Math.cos(mid_a) * mid_r})`;
         }
-        return `translate(${Math.sin(mid_a) * mid_r}, ${-Math.cos(mid_a) * mid_r})`;
-    }
-    if (mode === `radial`) {
-        if (!fits(radial_px, angular_px))
-            return null;
-        // Read outward, flipped on the left half so text is never upside down
-        const deg = to_degrees(mid_a) - 90;
-        const flip = mid_a > Math.PI ? 180 : 0;
-        return `rotate(${deg}) translate(${mid_r}, 0) rotate(${flip})`;
+        if (mode === `radial`) {
+            // fits() bounds the text by the ring thickness, so it stays inside r1
+            if (!fits(radial_px, angular_px))
+                continue;
+            // Read outward, flipped on the left half so text is never upside down
+            const deg = to_degrees(mid_a) - 90;
+            const flip = mid_a > Math.PI ? 180 : 0;
+            return `rotate(${deg}) translate(${mid_r}, 0) rotate(${flip})`;
+        }
+        // tangential: follow the circumference, flipped on the bottom half
+        if (!fits(angular_px, radial_px) || !inside_chart(mid_r))
+            continue;
+        const upside_down = mid_a > Math.PI / 2 && mid_a < (3 * Math.PI) / 2;
+        return `rotate(${to_degrees(mid_a)}) translate(0, ${-mid_r}) rotate(${upside_down ? 180 : 0})`;
     }
-    // tangential: follow the circumference, flipped on the bottom half
-    if (!fits(angular_px, radial_px))
-        return null;
-    const upside_down = mid_a > Math.PI / 2 && mid_a < (3 * Math.PI) / 2;
-    return `rotate(${to_degrees(mid_a)}) translate(0, ${-mid_r}) rotate(${upside_down ? 180 : 0})`;
+    return null;
 }

package/dist/plot/sunburst/sunburst.d.ts

@@ -1,13 +1,15 @@
 export type SunburstValueMode = `leaf-sum` | `total` | `remainder`;
 export type SunburstLabelRotation = `auto` | `radial` | `tangential` | `horizontal`;
 export type SunburstSort = `descending` | `ascending` | `none`;
-export type SunburstLabelText = `label` | `value` | `percent` | `label+value` | `label+percent`;
+export type SunburstLabelText = `label` | `value` | `percent` | `label+value` | `label+percent` | `label+parent-percent`;
 export type SunburstShape = `sunburst` | `icicle`;
 export interface SunburstNode<Metadata = Record<string, unknown>> {
     id?: string | number;
     label?: string;
+    label_short?: string;
     value?: number;
     color?: string;
+    hatch?: boolean;
     children?: SunburstNode<Metadata>[];
     metadata?: Metadata;
 }
@@ -21,6 +23,7 @@ export interface PositionedArc<Metadata = Record<string, unknown>> {
     parent_idx: number | null;
     id: string | number;
     label?: string;
+    label_short?: string;
     value: number;
     color: string;
     depth: number;
@@ -30,6 +33,7 @@ export interface PositionedArc<Metadata = Record<string, unknown>> {
     fraction: number;
     parent_fraction: number;
     is_other?: boolean;
+    hatch?: boolean;
     x0: number;
     x1: number;
     y0: number;

package/dist/plot/sunburst/sunburst.js

@@ -7,11 +7,14 @@
 import { hsl } from 'd3-color';
 import { hierarchy, partition } from 'd3-hierarchy';
 import { DEFAULT_SERIES_COLORS } from '../core/types';
+import { DEFAULTS } from '../../settings';
 // Compute normalized arc extents, resolved colors and breadcrumbs for a node tree.
 // Never mutates user data: d3-hierarchy wraps inputs in HierarchyNodes and all derived
 // fields (value overrides, ids, colors) are written onto the returned arcs only.
 export function compute_sunburst_layout(data, opts = {}) {
-    const { value_mode = `leaf-sum`, sort = `none`, level_lighten = 0, min_fraction = 0, other_label = `Other`, } = opts;
+    const { 
+    // value_mode/min_fraction fallbacks derive from DEFAULTS.sunburst to prevent drift
+    value_mode = DEFAULTS.sunburst.value_mode, sort = `none`, level_lighten = 0, min_fraction = DEFAULTS.sunburst.min_fraction, other_label = `Other`, } = opts;
     // Fresh object each call (not a shared constant) so callers can't corrupt each other
     if (Array.isArray(data) ? data.length === 0 : !data) {
         return { arcs: [], root: null, max_depth: 0 };
@@ -19,6 +22,10 @@ export function compute_sunburst_layout(data, opts = {}) {
     // Single root node is used directly; arrays get a synthetic invisible root
     const root_data = Array.isArray(data) ? { children: data } : data;
     const root = hierarchy(root_data, (node) => node.children);
+    // Coerce non-finite/negative input values to 0 at the source so downstream
+    // consumers (partition angles, treemap tiling, fractions in aria/hover labels)
+    // never see NaN or negative values.
+    const clean_value = (val) => typeof val === `number` && Number.isFinite(val) && val >= 0 ? val : 0;
     // 'remainder': d3's .sum() adds the node's own value on top of its children's sum,
     // which is exactly plotly's branchvalues='remainder'. 'leaf-sum' ignores parent values.
     // 'total': every explicitly set value is authoritative (plotly branchvalues='total');
@@ -26,18 +33,19 @@ export function compute_sunburst_layout(data, opts = {}) {
     // parent leave a trailing angular gap; more than the parent overflows (plotly errors
     // here; we warn and the component clamps angles).
     if (value_mode === `remainder`)
-        root.sum((node) => node.value ?? 0);
+        root.sum((node) => clean_value(node.value));
     else if (value_mode === `total`) {
         root.eachAfter((node) => {
             const child_sum = node.children?.reduce((sum, child) => sum + (child.value ?? 0), 0) ?? 0;
-            node.value = node.data.value ?? child_sum;
+            node.value =
+                node.data.value != null ? clean_value(node.data.value) : child_sum;
             if (node.children && node.data.value != null && child_sum > node.data.value + 1e-9) {
                 console.warn(`Sunburst: children of "${node.data.label ?? node.data.id ?? `root`}" sum to ${child_sum}, exceeding its value of ${node.data.value} (value_mode='total')`);
             }
         });
     }
     else
-        root.sum((node) => (node.children?.length ? 0 : (node.value ?? 0)));
+        root.sum((node) => (node.children?.length ? 0 : clean_value(node.value)));
     if (sort !== `none`) {
         const sign = sort === `descending` ? -1 : 1;
         root.sort((node_a, node_b) => sign * ((node_a.value ?? 0) - (node_b.value ?? 0)));
@@ -113,10 +121,12 @@ export function compute_sunburst_layout(data, opts = {}) {
         const arc = push_arc(parent, {
             id,
             label: node.data.label,
+            label_short: node.data.label_short,
             value: node.value ?? 0,
             color,
             depth,
             is_leaf: !node.children?.length,
+            hatch: node.data.hatch,
             x0,
             x1,
             y0,