matterviz 0.3.7 → 0.4.1

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

@@ -0,0 +1,97 @@
+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';
+import { type PositionedArc } from './sunburst';
+import { type ComponentProps, type 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?: SunburstNode<Metadata> | SunburstNode<Metadata>[];
+        shape?: SunburstShape;
+        value_mode?: SunburstValueMode;
+        sort?: SunburstSort;
+        level_lighten?: number;
+        min_fraction?: number;
+        other_label?: string;
+        max_depth?: number;
+        inner_radius?: number;
+        pad_angle?: number;
+        show_labels?: boolean;
+        label_rotation?: SunburstLabelRotation;
+        label_text?: SunburstLabelText;
+        zoom_on_click?: boolean;
+        zoom_root_id?: string | number | null;
+        show_breadcrumbs?: boolean;
+        color_values?: (arc: PositionedArc<Metadata>) => number | null;
+        color_scale?: D3InterpolateName;
+        color_range?: Vec2;
+        colorbar?: ComponentProps<typeof ColorBar> | null;
+        export_buttons?: boolean;
+        export_filename?: string;
+        tween?: TweenOptions<{
+            x0: number;
+            x1: number;
+            y0: number;
+            n_rings: number;
+        }>;
+        value_format?: string;
+        padding?: Sides;
+        legend?: LegendConfig | null;
+        show_legend?: boolean;
+        tooltip?: Snippet<[SunburstNodeHandlerProps<Metadata>]>;
+        arc_content?: Snippet<[{
+            arc: PositionedArc<Metadata>;
+            a0: number;
+            a1: number;
+            r0: number;
+            r1: number;
+        }]>;
+        center_content?: Snippet<[{
+            root: PositionedArc<Metadata> | null;
+            radius: number;
+            zoomed: boolean;
+        }]>;
+        change?: (data: SunburstNodeHandlerProps<Metadata> | null) => void;
+        on_node_click?: (data: SunburstNodeHandlerProps<Metadata> & {
+            event: MouseEvent | KeyboardEvent;
+        }) => void;
+        on_node_hover?: (data: (SunburstNodeHandlerProps<Metadata> & {
+            event: MouseEvent | FocusEvent;
+        }) | null) => void;
+        on_zoom?: (data: {
+            root: SunburstNodeHandlerProps<Metadata> | null;
+        }) => void;
+        header_controls?: Snippet<[{
+            height: number;
+            width: number;
+            fullscreen: boolean;
+        }]>;
+        controls_extra?: Snippet<[{
+            zoom_root_id: string | number | null;
+        }]>;
+    };
+    exports: {};
+    bindings: "data" | "show_controls" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "shape" | "value_mode" | "max_depth" | "inner_radius" | "pad_angle" | "min_fraction" | "label_rotation" | "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(): "data" | "show_controls" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "shape" | "value_mode" | "max_depth" | "inner_radius" | "pad_angle" | "min_fraction" | "label_rotation" | "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 Sunburst: $$IsomorphicComponent;
+type Sunburst<Metadata extends Record<string, unknown> = Record<string, unknown>> = InstanceType<typeof Sunburst<Metadata>>;
+export default Sunburst;

package/dist/plot/sunburst/SunburstControls.svelte

@@ -0,0 +1,200 @@
+<script lang="ts">
+  import { SettingsSection } from '../../layout'
+  import type {
+    SunburstLabelRotation,
+    SunburstLabelText,
+    SunburstShape,
+    SunburstValueMode,
+  } from '..'
+  import { DEFAULTS, SETTINGS_CONFIG } from '../../settings'
+  import type { Snippet } from 'svelte'
+  import type { HTMLAttributes } from 'svelte/elements'
+  import ControlPane from '../core/components/ControlPane.svelte'
+
+  let {
+    show_controls = $bindable(true),
+    controls_open = $bindable(false),
+    shape = $bindable(DEFAULTS.sunburst.shape),
+    value_mode = $bindable(DEFAULTS.sunburst.value_mode),
+    max_depth = $bindable(DEFAULTS.sunburst.max_depth),
+    inner_radius = $bindable(DEFAULTS.sunburst.inner_radius),
+    pad_angle = $bindable(DEFAULTS.sunburst.pad_angle),
+    min_fraction = $bindable(DEFAULTS.sunburst.min_fraction),
+    show_labels = $bindable(DEFAULTS.sunburst.show_labels),
+    label_rotation = $bindable(DEFAULTS.sunburst.label_rotation),
+    label_text = $bindable(DEFAULTS.sunburst.label_text),
+    zoom_on_click = $bindable(DEFAULTS.sunburst.zoom_on_click),
+    show_breadcrumbs = $bindable(DEFAULTS.sunburst.show_breadcrumbs),
+    export_buttons = true,
+    on_export,
+    toggle_props = {},
+    pane_props = {},
+    children,
+  }: {
+    show_controls?: boolean
+    controls_open?: boolean
+    shape?: SunburstShape
+    value_mode?: SunburstValueMode
+    max_depth?: number
+    inner_radius?: number
+    pad_angle?: number
+    min_fraction?: number
+    show_labels?: boolean
+    label_rotation?: SunburstLabelRotation
+    label_text?: SunburstLabelText
+    zoom_on_click?: boolean
+    show_breadcrumbs?: boolean
+    export_buttons?: boolean // show SVG/PNG download buttons in the pane
+    on_export?: (format: `svg` | `png`) => void
+    toggle_props?: HTMLAttributes<HTMLButtonElement>
+    pane_props?: HTMLAttributes<HTMLDivElement>
+    children?: Snippet
+  } = $props()
+</script>
+
+{#if show_controls}
+  <!-- snippets live at the template top level (not inside the components below) so
+  they're locally renderable rather than treated as ControlPane/SettingsSection props -->
+  {#snippet options(enum_map: Record<string, string>)}
+    {#each Object.entries(enum_map) as [value, label] (value)}
+      <option {value}>{label}</option>
+    {/each}
+  {/snippet}
+  {#snippet num_row(
+    text: string,
+    [min, max, step]: [number, number, number],
+    get: () => number,
+    set: (val: number) => void,
+  )}
+    <label style="flex: 1 1 100%">
+      {text}
+      <input type="range" {min} {max} {step} bind:value={get, set} />
+      <input type="number" {min} {max} {step} bind:value={get, set} />
+    </label>
+  {/snippet}
+  {#snippet check_row(text: string, get: () => boolean, set: (val: boolean) => void)}
+    <label style="flex: 1 1 100%">
+      <input type="checkbox" bind:checked={get, set} />
+      {text}
+    </label>
+  {/snippet}
+  <ControlPane bind:controls_open controls_class="sunburst" {toggle_props} {pane_props}>
+    {@render children?.()}
+    <SettingsSection
+      title="Sunburst"
+      current_values={{
+        shape,
+        value_mode,
+        max_depth,
+        inner_radius,
+        pad_angle,
+        min_fraction,
+        show_labels,
+        label_rotation,
+        label_text,
+        zoom_on_click,
+        show_breadcrumbs,
+      }}
+      on_reset={() => {
+        ;({
+          shape,
+          value_mode,
+          max_depth,
+          inner_radius,
+          pad_angle,
+          min_fraction,
+          show_labels,
+          label_rotation,
+          label_text,
+          zoom_on_click,
+          show_breadcrumbs,
+        } = DEFAULTS.sunburst)
+      }}
+      style="display: flex; flex-wrap: wrap; gap: 2ex"
+    >
+      <!-- select options come from the settings schema so labels/values have a
+      single source of truth -->
+      <label style="flex: 1">
+        Shape:
+        <select bind:value={shape}>
+          {@render options(SETTINGS_CONFIG.sunburst.shape.enum ?? {})}
+        </select>
+      </label>
+      <label style="flex: 1">
+        Value mode:
+        <select bind:value={value_mode}>
+          {@render options(SETTINGS_CONFIG.sunburst.value_mode.enum ?? {})}
+        </select>
+      </label>
+      {#if shape === `sunburst`}
+        <!-- icicle labels are always horizontal; inner radius/pad angle are polar-only -->
+        <label style="flex: 1">
+          Labels:
+          <select bind:value={label_rotation}>
+            {@render options(SETTINGS_CONFIG.sunburst.label_rotation.enum ?? {})}
+          </select>
+        </label>
+      {/if}
+      <label style="flex: 1">
+        Label text:
+        <select bind:value={label_text}>
+          {@render options(SETTINGS_CONFIG.sunburst.label_text.enum ?? {})}
+        </select>
+      </label>
+      {@render num_row(`Max depth (0 = all):`, [0, 10, 1], () => max_depth, (val) =>
+        max_depth = val)}
+      {#if shape === `sunburst`}
+        {@render num_row(`Inner radius:`, [0, 0.8, 0.05], () => inner_radius, (val) =>
+          inner_radius = val)}
+        {@render num_row(`Pad angle (°):`, [0, 4, 0.1], () => pad_angle, (val) =>
+          pad_angle = val)}
+      {/if}
+      {@render num_row(
+        `Group slices below (fraction of total):`,
+        [0, 0.2, 0.005],
+        () => min_fraction,
+        (val) => min_fraction = val,
+      )}
+      {@render check_row(`Show arc labels`, () => show_labels, (val) =>
+        show_labels = val)}
+      {@render check_row(`Zoom on click`, () => zoom_on_click, (val) =>
+        zoom_on_click = val)}
+      {@render check_row(`Show breadcrumbs when zoomed`, () => show_breadcrumbs, (val) =>
+        show_breadcrumbs = val)}
+    </SettingsSection>
+    {#if export_buttons && on_export}
+      <div class="export-row">
+        Export:
+        {#each [`svg`, `png`] as const as fmt (fmt)}
+          <button
+            type="button"
+            class="export-btn"
+            aria-label="Download {fmt.toUpperCase()}"
+            onclick={() => on_export?.(fmt)}
+          >{fmt.toUpperCase()}</button>
+        {/each}
+      </div>
+    {/if}
+  </ControlPane>
+{/if}
+
+<style>
+  .export-row {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    margin-top: 6px;
+    font-size: 0.85em;
+  }
+  .export-btn {
+    background: var(--sunburst-btn-bg, rgba(128, 128, 128, 0.15));
+    color: inherit;
+    border: none;
+    border-radius: 3pt;
+    padding: 1px 6px;
+    cursor: pointer;
+  }
+  .export-btn:hover {
+    background: var(--sunburst-btn-hover-bg, rgba(128, 128, 128, 0.35));
+  }
+</style>

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

@@ -0,0 +1,26 @@
+import type { SunburstLabelRotation, SunburstLabelText, SunburstShape, SunburstValueMode } from '..';
+import type { Snippet } from 'svelte';
+import type { HTMLAttributes } from 'svelte/elements';
+type $$ComponentProps = {
+    show_controls?: boolean;
+    controls_open?: boolean;
+    shape?: SunburstShape;
+    value_mode?: SunburstValueMode;
+    max_depth?: number;
+    inner_radius?: number;
+    pad_angle?: number;
+    min_fraction?: number;
+    show_labels?: boolean;
+    label_rotation?: SunburstLabelRotation;
+    label_text?: SunburstLabelText;
+    zoom_on_click?: boolean;
+    show_breadcrumbs?: boolean;
+    export_buttons?: boolean;
+    on_export?: (format: `svg` | `png`) => void;
+    toggle_props?: HTMLAttributes<HTMLButtonElement>;
+    pane_props?: HTMLAttributes<HTMLDivElement>;
+    children?: Snippet;
+};
+declare const SunburstControls: import("svelte").Component<$$ComponentProps, {}, "show_controls" | "show_labels" | "controls_open" | "shape" | "value_mode" | "max_depth" | "inner_radius" | "pad_angle" | "min_fraction" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs">;
+type SunburstControls = ReturnType<typeof SunburstControls>;
+export default SunburstControls;

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

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

package/dist/plot/sunburst/index.js

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

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

@@ -0,0 +1,34 @@
+import type { PositionedArc, SunburstLabelRotation, SunburstShape } from './sunburst';
+export interface ScreenArc<Metadata = Record<string, unknown>> {
+    arc: PositionedArc<Metadata>;
+    a0: number;
+    a1: number;
+    r0: number;
+    r1: number;
+    visible: boolean;
+}
+export interface ViewWindow {
+    x0: number;
+    x1: number;
+    y0: number;
+    n_rings: number;
+}
+export interface ScreenGeometry {
+    shape: SunburstShape;
+    inner_width: number;
+    inner_height: number;
+    radius: number;
+    hole_r: number;
+}
+export declare function project_arcs<Metadata>(arcs: PositionedArc<Metadata>[], win: ViewWindow, geom: ScreenGeometry): {
+    all: ScreenArc<Metadata>[];
+    visible: ScreenArc<Metadata>[];
+};
+export declare function arrow_nav_target<Metadata>(arcs: readonly PositionedArc<Metadata>[], is_visible: (idx: number) => boolean, current_idx: number, key: string): number | null;
+export declare function arc_label_transform(d: {
+    a0: number;
+    a1: number;
+    r0: number;
+    r1: number;
+}, text_w: number, // rendered text width in px
+shape: SunburstShape, rotation: SunburstLabelRotation): string | null;

package/dist/plot/sunburst/render.js

@@ -0,0 +1,122 @@
+// Screen-space math for Sunburst/Icicle rendering: projecting normalized partition
+// coordinates through a zoom window into pixels, and fitting labels into arcs/cells.
+// 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';
+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.
+export function project_arcs(arcs, win, geom) {
+    const span = Math.max(win.x1 - win.x0, 1e-9);
+    const icicle = geom.shape === `icicle`;
+    const x_scale = icicle ? geom.inner_width : TWO_PI; // angle/x per window fraction
+    const y_offset = icicle ? 0 : geom.hole_r;
+    const y_unit = (icicle ? geom.inner_height : Math.max(0, geom.radius - geom.hole_r)) /
+        Math.max(win.n_rings, 1e-9); // px per ring
+    const min_x_extent = icicle ? 0.1 : 1e-6;
+    // Window fraction -> angle/x (clamped: out-of-window arcs collapse to zero extent
+    // and animate smoothly through the clamps during zoom tweens)
+    const x_of = (frac) => clamp01((frac - win.x0) / span) * x_scale;
+    // Ring offset below the zoom root -> radius/y, clamped into the visible rings
+    const y_of = (ring) => y_offset + Math.min(Math.max(ring - win.y0 - 1, 0), win.n_rings) * y_unit;
+    const all = [];
+    const visible = [];
+    for (const arc of arcs) {
+        const a0 = x_of(arc.x0);
+        const a1 = x_of(arc.x1);
+        const r0 = y_of(arc.y0);
+        const r1 = y_of(arc.y1);
+        const is_visible = arc.depth > 0 && a1 - a0 > min_x_extent && r1 - r0 > 0.1;
+        const screen = { arc, a0, a1, r0, r1, visible: is_visible };
+        all.push(screen);
+        if (screen.visible)
+            visible.push(screen);
+    }
+    return { all, visible };
+}
+// Arrow-key navigation over the pre-order arc array: ArrowLeft/ArrowRight cycle
+// through visible siblings (wrapping), ArrowDown enters the first child, ArrowUp
+// returns to the parent (never the hidden root at depth 0). Visibility is delegated
+// to is_visible (the component supplies screen-space collapse state). Returns the
+// target node_idx, or null when the key isn't an arrow key or no target qualifies.
+export function arrow_nav_target(arcs, is_visible, current_idx, key) {
+    if (![`ArrowRight`, `ArrowLeft`, `ArrowUp`, `ArrowDown`].includes(key))
+        return null;
+    const cur = arcs[current_idx];
+    if (!cur)
+        return null;
+    if (key === `ArrowDown`) {
+        // pre-order: a branch's first child directly follows it
+        const child = arcs[cur.node_idx + 1];
+        return child && child.parent_idx === cur.node_idx && is_visible(child.node_idx)
+            ? child.node_idx
+            : null;
+    }
+    const parent = cur.parent_idx != null ? arcs[cur.parent_idx] : null;
+    if (key === `ArrowUp`) {
+        return parent && parent.depth > 0 && is_visible(parent.node_idx) ? parent.node_idx : null;
+    }
+    // Walk siblings via the contiguous pre-order subtree ranges (each sibling starts
+    // right after the previous one's subtree ends) - pre-order also matches angular
+    // order, so no sorting needed and no full-arcs scan per keypress
+    const last = parent?.subtree_end ?? arcs.length - 1;
+    const siblings = [];
+    for (let idx = (parent?.node_idx ?? 0) + 1; idx <= last; idx = arcs[idx].subtree_end + 1) {
+        if (is_visible(idx))
+            siblings.push(idx);
+    }
+    if (siblings.length < 2)
+        return null;
+    const pos = siblings.indexOf(cur.node_idx);
+    const step = key === `ArrowRight` ? 1 : -1;
+    return siblings[(pos + step + siblings.length) % siblings.length];
+}
+// Arc label placement: fit the text radially or tangentially (whichever has more room
+// 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) {
+    // 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;
+    if (shape === `icicle`) {
+        const cell_w = d.a1 - d.a0;
+        const cell_h = d.r1 - d.r0;
+        const center = `translate(${(d.a0 + d.a1) / 2}, ${(d.r0 + d.r1) / 2})`;
+        // Horizontal when the text fits the row width; otherwise rotate 90° (read
+        // bottom-up) to use a thin-but-tall cell's height. Only cells too small in both
+        // dimensions stay unlabeled.
+        if (fits(cell_w, cell_h))
+            return center;
+        if (fits(cell_h, cell_w))
+            return `${center} rotate(-90)`;
+        return null;
+    }
+    const mid_a = (d.a0 + d.a1) / 2;
+    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;
+        }
+        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})`;
+    }
+    // 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})`;
+}

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

@@ -0,0 +1,62 @@
+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 SunburstShape = `sunburst` | `icicle`;
+export interface SunburstNode<Metadata = Record<string, unknown>> {
+    id?: string | number;
+    label?: string;
+    value?: number;
+    color?: string;
+    children?: SunburstNode<Metadata>[];
+    metadata?: Metadata;
+}
+export interface SunburstNodeHandlerProps<Metadata = Record<string, unknown>> extends Omit<PositionedArc<Metadata>, `x0` | `x1` | `y0` | `y1` | `subtree_end` | `parent_idx`> {
+    type: `node`;
+    parent_id: string | number | null;
+}
+export interface PositionedArc<Metadata = Record<string, unknown>> {
+    node_idx: number;
+    subtree_end: number;
+    parent_idx: number | null;
+    id: string | number;
+    label?: string;
+    value: number;
+    color: string;
+    depth: number;
+    is_leaf: boolean;
+    path: (string | number)[];
+    label_path: string[];
+    fraction: number;
+    parent_fraction: number;
+    is_other?: boolean;
+    x0: number;
+    x1: number;
+    y0: number;
+    y1: number;
+    metadata?: Metadata;
+}
+export interface SunburstLayoutOptions {
+    value_mode?: SunburstValueMode;
+    sort?: SunburstSort;
+    level_lighten?: number;
+    min_fraction?: number;
+    other_label?: string;
+}
+export interface SunburstLayoutResult<Metadata = Record<string, unknown>> {
+    arcs: PositionedArc<Metadata>[];
+    root: PositionedArc<Metadata> | null;
+    max_depth: number;
+}
+export declare function compute_sunburst_layout<Metadata = Record<string, unknown>>(data: SunburstNode<Metadata> | SunburstNode<Metadata>[], opts?: SunburstLayoutOptions): SunburstLayoutResult<Metadata>;
+export declare function sunburst_from_paths<Metadata = Record<string, unknown>>(rows: readonly {
+    path: readonly (string | number)[];
+    value: number;
+    color?: string;
+    metadata?: Metadata;
+}[]): SunburstNode<Metadata>[];
+export declare function sunburst_from_labels_parents<Metadata = Record<string, unknown>>(labels: readonly string[], parents: readonly (string | null | undefined)[], values?: readonly number[], opts?: {
+    ids?: readonly (string | number)[];
+    colors?: readonly (string | undefined)[];
+    metadata?: readonly (Metadata | undefined)[];
+}): SunburstNode<Metadata>[];