@k2b/ui 0.50.0 → 0.52.0

package/dist/types/actions/Button.d.ts

@@ -1,7 +1,7 @@
 import { type LinkNavigateEvent, type NavigationScrollMode } from "@k2b/ssr/nav";
 import { type JSX } from "solid-js";
 import { type TooltipPlacement } from "../feedback/Tooltip";
-export type ButtonVariant = "primary" | "secondary" | "ghost" | "text" | "subtle" | "input" | "warning" | "danger" | "success" | "ai";
+export type ButtonVariant = "primary" | "secondary" | "ghost" | "text" | "link" | "subtle" | "input" | "warning" | "danger" | "success" | "ai";
 export type ButtonSize = "xs" | "sm" | "md" | "lg";
 export type ButtonAlign = "center" | "start";
 export type ButtonProps = JSX.ButtonHTMLAttributes<HTMLButtonElement> & {

package/dist/types/actions/CommandList.d.ts

@@ -0,0 +1,120 @@
+import { type Accessor, type JSX } from "solid-js";
+import { type CommandContext, type CommandGroup, type CommandItem, type CommandSource } from "./command-items";
+/** The state of one open command list: its steps, the shown entries, and the marked one. */
+export type CommandNavigator = ReturnType<typeof createCommandNavigator>;
+/** The context without what the list adds itself: the query, the path, the signal, and the reports. */
+export type CommandPlace = Omit<CommandContext, "query" | "path" | "signal" | "success" | "error">;
+/** A list whose entries come from a promise: pending, or failed with the message of its rejection. */
+export type CommandListLoad = {
+    state: "ready";
+} | {
+    state: "loading";
+} | {
+    state: "failed";
+    message?: string;
+};
+/** A command that returned a promise, busy while it runs. */
+export type CommandStatus = {
+    key: string;
+    label: string;
+    state: "running";
+};
+/**
+ * What a finished command reported, shown in the list's place: a confirmation, an error (with a way to try again when
+ * the command threw or rejected), or the command running again after a retry.
+ */
+export type CommandOutcome = {
+    state: "success";
+    message: string;
+} | {
+    state: "error";
+    message?: string;
+    retry?: () => void;
+} | {
+    state: "running";
+    message: string;
+};
+/** A confirmation or an error stays at least this long, even when the person types on at once. */
+export declare const COMMAND_OUTCOME_MIN_MS = 1200;
+/** A confirmation goes by itself after this long; an error stays until the person types, retries, or presses Escape. */
+export declare const COMMAND_OUTCOME_SUCCESS_MS = 4000;
+/**
+ * Keeps the steps, the marked entry, and the running command of a command list. The host owns the query and the
+ * effects: `onText` places an entry's text; for an entry with `onSelect`, `beforeRun` lets the host remove its query,
+ * `context` describes the text the command acts on, and `afterRun` closes the list once the command finished.
+ * `onStep` runs after a further list opened or closed, with the new depth, so the host clears its query.
+ */
+export declare const createCommandNavigator: (options: {
+    items: Accessor<CommandSource>;
+    query: Accessor<string>;
+    onText: (item: CommandItem) => void;
+    /** The part of the context the host knows: the text and where the list is in it. */
+    context: () => CommandPlace;
+    /** Whether the list is open; a closed list asks no source. */
+    active: () => boolean;
+    beforeRun?: () => void;
+    /** Runs once a command finished, before its outcome shows; `outcome` tells the host to keep its place for it. */
+    afterRun: (outcome: boolean) => void;
+    onStep?: (depth: number) => void;
+}) => {
+    query: Accessor<string>;
+    step: () => CommandItem | undefined;
+    groups: Accessor<CommandGroup[]>;
+    entries: Accessor<CommandItem[]>;
+    active: Accessor<number>;
+    setActive: (index: number) => void;
+    /** Marks the next or previous entry, wrapping; unavailable entries are passed over, as in a searchable menu. */
+    move: (delta: 1 | -1) => void;
+    edge: (which: "first" | "last") => void;
+    status: Accessor<CommandStatus | undefined>;
+    load: Accessor<CommandListLoad>;
+    /** Asks a source whose promise failed again. */
+    retry: () => number;
+    /** Whether a command's promise is pending; the list then waits for it. */
+    busy: () => boolean;
+    choose: (index?: number) => void;
+    /** Enter while entries load: chooses the first entry of this query once it arrives. */
+    chooseWhenLoaded: () => string;
+    /** Whether a choice waits for entries on their way. */
+    awaitingChoice: () => boolean;
+    /** Stops a running command: its signal aborts, and its result no longer reaches the list. */
+    abort: () => void;
+    /** What the last command reported, shown in the list's place until it clears. */
+    outcome: Accessor<CommandOutcome | undefined>;
+    /** The person typed on: the outcome clears, but not before it showed for `COMMAND_OUTCOME_MIN_MS`. */
+    typedOn: () => void;
+    /** Clears the outcome at once, for Escape or a new list; a retry still running is stopped. */
+    clearOutcome: () => void;
+    /** Leaves the second list; `false` when the first list shows. */
+    back: () => boolean;
+    /**
+     * Forgets steps, mark, and status. A running command goes on, but its result no longer reaches the list, so a
+     * retry's running line goes too; a reported outcome stays until it clears.
+     */
+    reset: () => void;
+};
+export declare const commandOptionId: (listId: string, index: number) => string;
+/**
+ * The rows of a command list as a list box, with the menu's own rows and headings. The focus stays in the host's
+ * field, which points at the marked row as its active descendant; the rows only answer the pointer.
+ */
+export declare function CommandList(props: {
+    navigator: CommandNavigator;
+    id: string;
+    /** Names the first list; a second list is named by its step. */
+    label: string;
+    /** Shows the step's label beside the back control, for a host without its own search field. */
+    stepHint?: boolean;
+    /** Says how many entries match, after the query changed. */
+    query: Accessor<string>;
+    /** Content between the back control and the list, such as a search field. */
+    header?: JSX.Element;
+    /** Runs after Retry or Close on an outcome, so the host puts the focus back where the person writes. */
+    onOutcomeAction?: () => void;
+}): JSX.Element;
+/**
+ * The keys of a command list in its host's field: Up, Down, Home, and End mark; Enter and Tab choose; Escape and
+ * Backspace on an empty query leave a second list. Returns whether the key was used; Escape in the first list is left
+ * to the host, which closes.
+ */
+export declare const commandListKey: (nav: CommandNavigator, event: KeyboardEvent, query: string) => boolean;

package/dist/types/actions/CommandMenu.d.ts

@@ -0,0 +1,39 @@
+import { type JSX } from "solid-js";
+import { type CommandSource } from "./command-items";
+import { Dropdown, type DropdownAnchor, type DropdownPosition, type DropdownReturnFocus } from "./Dropdown";
+export type CommandMenuProps = {
+    /** The same entries as `MarkdownEditor`'s `commands`, so the slash menu, a "+" button, and a chip offer one list. */
+    items: CommandSource;
+    /** Names the menu and its first list, such as "Add to message". */
+    label: string;
+    /** Names the search field and is its hint, such as "Search commands". A second list shows its own label there. */
+    search: string;
+    /**
+     * The field the commands act on, such as the composer's textarea beside a "+" button. Its text and selection are the
+     * `context` of an `onSelect`, and `context.insert` and entries with `text` write into it as typing would.
+     */
+    target?: HTMLTextAreaElement | HTMLInputElement;
+    /**
+     * The composer box the menu docks to, as the slash list does: as wide as the box, just above it, or below it when
+     * there is more room there. Without it, the menu opens beside its trigger.
+     */
+    dock?: HTMLElement;
+    /** Receives inserted text when there is no `target`, such as a snippet the host places itself. */
+    onInsert?: (text: string) => void;
+    /** The `CommandMenu.Trigger`; leave it out for a menu opened through `openAt` or `attach`. */
+    children?: JSX.Element;
+    position?: DropdownPosition;
+    align?: "start" | "end";
+    /** Receives `open`, which shows the menu beside `anchor` without its trigger; focus returns to `returnFocus`. */
+    openAt?: (open: (anchor: DropdownAnchor, returnFocus?: DropdownReturnFocus) => void) => void;
+    /** Adopts an element rendered elsewhere, such as a server-rendered chip, as the trigger. */
+    attach?: () => HTMLElement | null | undefined;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    class?: string;
+};
+type CommandMenuComponent = ((props: CommandMenuProps) => JSX.Element) & {
+    Trigger: typeof Dropdown.Trigger;
+};
+export declare const CommandMenu: CommandMenuComponent;
+export {};

package/dist/types/actions/Dropdown.d.ts

@@ -1,6 +1,7 @@
 import { type JSX } from "solid-js";
 import { type TooltipPlacement } from "../feedback/Tooltip";
 import { type ButtonProps, type ButtonSize, type ButtonVariant } from "./Button";
+import { type MenuSearchApi } from "./menu-search";
 export type DropdownPosition = "bottom-right" | "bottom-left" | "top-right" | "top-left" | "right-start";
 /** Where a menu opened without its trigger appears: an element, or any box such as a point inside one. */
 export type DropdownAnchor = {
@@ -198,10 +199,26 @@ export declare function DropdownItems(props: {
     close: (restoreFocus?: boolean) => void;
     role?: "menuitem" | "option";
 }): JSX.Element;
+/**
+ * Internal: content in place of the entries, as `CommandMenu` renders its command list. It reports where the focus
+ * goes as the menu opens, like the search field, and `open` tells it when the menu closed.
+ */
+export type DropdownBody = (props: {
+    close: (restoreFocus?: boolean) => void;
+    open: () => boolean;
+    api: (api: MenuSearchApi) => void;
+}) => JSX.Element;
+/** Accessible top-layer menu with explicit trigger ownership. */
+declare function DropdownRoot(props: DropdownProps & {
+    body?: DropdownBody;
+    placeMenu?: (menu: HTMLElement) => void;
+}): JSX.Element;
 type DropdownComponent = ((props: DropdownProps) => JSX.Element) & {
     Root: (props: DropdownProps) => JSX.Element;
     Trigger: (props: DropdownTriggerProps) => JSX.Element;
     Item: (props: DropdownItemProps) => JSX.Element;
 };
+/** Internal: the menu with a `body`, for `CommandMenu`. */
+export declare const DropdownShell: typeof DropdownRoot;
 export declare const Dropdown: DropdownComponent;
 export default Dropdown;

package/dist/types/actions/Toolbar.d.ts

@@ -21,6 +21,8 @@ export type ToolbarActionProps = {
     /** 1 is most important. Larger numbers move first; ties move later DOM actions first. Omit to keep fixed. */
     priority?: number;
     disabled?: boolean;
+    /** Makes the action a toggle and exposes its state as `aria-pressed`, such as Bold over bold text. */
+    pressed?: boolean;
     onClick?: () => void;
 };
 export type ToolbarLabelProps = {

package/dist/types/actions/command-dock.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Docks a command list to its composer: exactly as wide as the composer and flush with its edges, just above it, or
+ * below it when the visible viewport leaves more room there, as for a composer at the top. The visible viewport counts,
+ * so a phone's open keyboard does not hide the list. The list scrolls within the room it gets.
+ */
+export declare const dockCommandList: (list: HTMLElement, composer: Element) => void;
+/** Calls `follow` whenever the composer or the visible viewport moves or changes size; returns the cleanup. */
+export declare const followComposer: (composer: Element, follow: () => void) => () => void;

package/dist/types/actions/command-items.d.ts

@@ -0,0 +1,134 @@
+import type { JSX } from "solid-js";
+/**
+ * One entry of a command list: the slash menu of `MarkdownEditor` and `CommandMenu` read the same entries, so a
+ * composer's `/`, its "+" button, and a chip offer one list.
+ */
+/** Where a slash at `start` stands in `value`: the text before it and whether only whitespace precedes it, overall or on its line. */
+export declare const commandPlace: (value: string, start: number, end: number) => {
+    text: string;
+    before: string;
+    atStart: boolean;
+    lineStart: boolean;
+};
+export type CommandItem = {
+    label: string;
+    /** Heading above the entry. Entries of one group stand together, in the order the groups first appear. */
+    group?: string;
+    /** One quiet line of what the entry does, after the label on the same line, such as "Preis aus dem Text prüfen". */
+    description?: string;
+    /** Quiet text at the end of the row, such as what a person can type: `/telefonat`. It is searched, too. */
+    hint?: string;
+    /** Tabler icon class, such as `ti ti-phone`. */
+    icon?: string;
+    /**
+     * An image at icon size in place of the icon, such as a service's logo: a URL, or one for each theme when the logo
+     * needs a light variant on dark surfaces. It is decorative; the label names the entry.
+     */
+    image?: string | {
+        light: string;
+        dark: string;
+    };
+    /**
+     * Renders the start of the row in place of the icon, such as an avatar or a tag's color. A function, so each row
+     * gets its own element.
+     */
+    leading?: () => JSX.Element;
+    /** Further words that find the entry, such as "anruf" for "Phone call". */
+    keywords?: readonly string[];
+    /** Unavailable now: the entry stays in the list, greyed, with this one-line reason, and cannot be chosen. */
+    disabled?: string;
+    /** Stable key, when two entries share group and label. */
+    id?: string;
+} & ({
+    /**
+     * Runs when the entry is chosen, with the text it acts on. In the editor, the typed `/query` has left the text
+     * first. A returned promise keeps the list open with the entry busy; any other result counts as done; a rejection shows its message on the entry,
+     * which can then run again, and Escape aborts `context.signal`.
+     */
+    onSelect: (context: CommandContext) => unknown;
+    text?: never;
+    next?: never;
+} | {
+    /** Text that takes the place of the typed `/query`; `CommandMenu` hands it to `onInsert`. */
+    text: string;
+    onSelect?: never;
+    next?: never;
+} | {
+    /** A second list in the same popover, such as people to assign. */
+    next: CommandStep;
+    onSelect?: never;
+    text?: never;
+});
+/**
+ * Where a command list is and what it acts on: one context for the entries of every level and for `onSelect`. In
+ * `SlashCommands` the text is the editor's, without the typed `/query`; in `CommandMenu` it is the text of its `target`
+ * field, or empty without one.
+ */
+export type CommandContext = {
+    /** What the person typed after `/`, or into the menu's search field. */
+    query: string;
+    /** The whole text without the typed `/query`. */
+    text: string;
+    /** The text before the slash, or before the caret in `CommandMenu`. */
+    before: string;
+    /** Whether the slash is the first character of the text, leading whitespace aside. */
+    atStart: boolean;
+    /** Whether the slash starts a line, leading whitespace aside. */
+    lineStart: boolean;
+    /** The selection in `text`; `start === end` is the caret. */
+    selection: {
+        start: number;
+        end: number;
+    };
+    /** The entries chosen so far on the way to this level, such as `[assign, person]` on the third. */
+    path: readonly CommandItem[];
+    /**
+     * Puts text at the caret in place of the selection, as typing would, so undo keeps working. Without a `target`,
+     * `CommandMenu` hands it to `onInsert`. Meant for `onSelect`.
+     */
+    insert: (text: string) => void;
+    /**
+     * Reports what a command did, such as "Valentin Brandt zugewiesen": after the command finished, the list gives way to
+     * a short confirmation in the same place. Meant for `onSelect`; an entry source has its own loading and failure.
+     */
+    success: (message: string) => void;
+    /**
+     * Reports why a command could not do it, such as "Keine Artikelnummer im Text"; it stays until the person types on
+     * or presses Escape. A command that throws or rejects reports its error itself, with a way to try again.
+     */
+    error: (message: string) => void;
+    /**
+     * Aborts when the result is no longer wanted: a new query replaces a pending list, or the person closes the list
+     * with Escape before a command's promise settled.
+     */
+    signal: AbortSignal;
+};
+/**
+ * The entries of a list: a list, or a function of the context that decides which entries there are in this place, at
+ * once or as a promise, such as templates only at the start of the text or people from a server search. Either way the
+ * list filters them by the query; give server matches the words they matched on as `keywords`.
+ */
+export type CommandSource = readonly CommandItem[] | ((context: CommandContext) => readonly CommandItem[] | Promise<readonly CommandItem[]>);
+/** A further list in the same place, as deep as needed. Escape, or Backspace on an empty query, goes back. */
+export type CommandStep = {
+    /** Names the list and is the search hint, such as "Search person". */
+    label: string;
+    items: CommandSource;
+};
+export type CommandGroup = {
+    label?: string;
+    entries: {
+        item: CommandItem;
+        index: number;
+    }[];
+};
+/**
+ * The entries whose label, hint, or keywords contain every word of the query, ignoring case and accents, in their
+ * order. A blank query keeps all.
+ */
+export declare const filterCommandItems: (items: readonly CommandItem[], query: string) => readonly CommandItem[];
+/** The entries of a source in a context, filtered by its query; a promise resolves to the filtered entries. */
+export declare const resolveCommandSource: (source: CommandSource, context: CommandContext) => readonly CommandItem[] | Promise<readonly CommandItem[]>;
+/** Groups in the order they first appear; `index` is the entry's place in the order the list shows. */
+export declare const groupCommandItems: (items: readonly CommandItem[]) => CommandGroup[];
+export declare const commandKey: (item: CommandItem) => string;

package/dist/types/actions/command-messages.d.ts

@@ -0,0 +1,19 @@
+declare const commandMessages: import("@k2b/stdlib").Catalog<{
+    commands: string;
+    back: ({ label }: {
+        label: string;
+    }) => string;
+    running: ({ label }: {
+        label: string;
+    }) => string;
+    failed: string;
+    loading: string;
+    loadingChoice: string;
+    loadFailed: string;
+    done: string;
+}>;
+export type CommandMessages = ReturnType<(typeof commandMessages)["resolve"]>["t"];
+/** Resolved from the inherited render locale. */
+export declare const useCommandMessages: () => (() => CommandMessages);
+export declare const checkCommandMessages: () => import("@k2b/stdlib").CatalogIssue[];
+export {};

package/dist/types/actions/index.d.ts

@@ -1,9 +1,12 @@
 export type { ButtonAlign, ButtonLinkProps, ButtonProps, ButtonSize, ButtonVariant, IconButtonLinkProps, IconButtonProps } from "./Button";
 export { Button, ButtonLink, IconButton, IconButtonLink } from "./Button";
+export type { CommandMenuProps } from "./CommandMenu";
+export { CommandMenu } from "./CommandMenu";
 export type { ContextMenuProps } from "./ContextMenu";
 export { ContextMenu } from "./ContextMenu";
 export type { CopyButtonProps, CopyButtonValue } from "./CopyButton";
 export { CopyButton } from "./CopyButton";
+export type { CommandContext, CommandItem, CommandSource, CommandStep } from "./command-items";
 export type { DisclosureProps } from "./Disclosure";
 export { Disclosure } from "./Disclosure";
 export type { DragPayload, DragSourceProps, DropTargetProps } from "./DragAndDrop";

package/dist/types/charts/core/bar-labels.d.ts

@@ -0,0 +1 @@
+export declare const barPercent: (locale?: string) => Intl.NumberFormat;

package/dist/types/charts/core/bubble.d.ts

@@ -0,0 +1,66 @@
+import { type ChartOptions } from "./svg";
+export type BubbleOptions = ChartOptions & {
+    groups: string[];
+    data: {
+        label: string;
+        group: string;
+        x: number;
+        y: number;
+        size?: number;
+    }[];
+    xLabel: string;
+    yLabel: string;
+    sizeLabel?: string;
+    averages?: boolean;
+    legend?: boolean;
+    locale?: string;
+    xFormat?: (value: number) => string;
+    yFormat?: (value: number) => string;
+    sizeFormat?: (value: number) => string;
+    displayWidth?: number;
+};
+export declare function bubbleLayout(spec: BubbleOptions, size?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+    header: {
+        svg: string;
+        height: number;
+    };
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    xd: readonly [number, number];
+    yd: readonly [number, number];
+    x: (value: number) => number;
+    y: (value: number) => number;
+    points: {
+        label: string;
+        group: string;
+        x: number;
+        y: number;
+        size?: number;
+        index: number;
+        cx: number;
+        cy: number;
+        radius: number;
+        labelBox: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | undefined;
+    }[];
+    meanX: number;
+    meanY: number;
+    legend: {
+        label: string;
+        index: number;
+        x: number;
+        row: number;
+    }[];
+};
+export declare function renderBubbleSvg(spec: BubbleOptions): string;

package/dist/types/charts/core/calendar.d.ts

@@ -1,4 +1,4 @@
-import { type ChartOptions, type HeatmapOptions } from "./svg";
+import { type ChartOptions, type HeatmapOptions } from "./svg-renderers";
 export type CalendarHeatmapOptions = ChartOptions & {
     layout: "calendar";
     data: [string, number | null][];

package/dist/types/charts/core/chart-messages.d.ts

@@ -0,0 +1,5 @@
+/** Labels needed by pure SVG renderers; UI inspection messages stay with the UI host. */
+export declare const coreChartMessages: import("@k2b/stdlib").Catalog<{
+    series: string;
+    areaTotal: string;
+}>;

package/dist/types/charts/core/default-styles.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_STYLES: string;

package/dist/types/charts/core/funnel-layout.d.ts

@@ -0,0 +1,43 @@
+import type { ChartDatum } from "./types";
+export type FunnelOptions = {
+    data: {
+        label: string;
+        value: number | null;
+    }[];
+    valueFormat?: (value: number) => string;
+    locale?: string;
+    title?: string;
+    subtitle?: string;
+    className?: string;
+};
+/** Ratios use the original start/previous observation. Geometry fits the largest observed step, including rises. */
+export declare function funnelLayout(spec: FunnelOptions, size?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    height: number;
+    unit: number;
+    left: number;
+    right: number;
+    center: number;
+    top: number;
+    pitch: number;
+    barHeight: number;
+    steps: {
+        label: string;
+        value: number | null;
+        index: number;
+        center: number;
+        y: number;
+        width: number;
+        startShare: number | null;
+        previousShare: number | null;
+        datum: ChartDatum;
+        labelLines: string[];
+        valueText: string;
+        shareText: string;
+        title: string;
+    }[];
+};
+export type FunnelLayout = ReturnType<typeof funnelLayout>;

package/dist/types/charts/core/funnel.d.ts

@@ -0,0 +1,13 @@
+import { type FunnelLayout, type FunnelOptions } from "./funnel-layout";
+export { type FunnelLayout, type FunnelOptions, funnelLayout } from "./funnel-layout";
+export declare function renderFunnelSvg(spec: FunnelOptions & {
+    width: number;
+    height: number;
+    inspect?: boolean;
+}): string;
+/** Draw the same geometry reserved before a lazy host loads its renderer. */
+export declare function renderFunnelLayoutSvg(spec: FunnelOptions & {
+    width: number;
+    height: number;
+    inspect?: boolean;
+}, g: FunnelLayout): string;

package/dist/types/charts/core/hbar-layout.d.ts

@@ -0,0 +1,74 @@
+import type { ChartDatum } from "./types";
+export type HorizontalBarOptions = {
+    series: string[];
+    rows: {
+        group?: string;
+        label: string;
+        values: (number | null)[];
+    }[];
+    valueFormat?: (value: number) => string;
+    legend?: boolean;
+    title?: string;
+    subtitle?: string;
+    locale?: string;
+    className?: string;
+};
+/** Stacks start at zero, group headings keep their first-appearance order. */
+export declare function hbarLayout(spec: HorizontalBarOptions, size?: {
+    width: number;
+    height: number;
+}): {
+    width: number;
+    header: number;
+    height: number;
+    top: number;
+    left: number;
+    right: number;
+    rows: {
+        group?: string;
+        label: string;
+        values: (number | null)[];
+        labelLines: string[];
+        groupHeading: string | undefined;
+        index: number;
+        center: number;
+        segments: {
+            value: number | null;
+            seriesIndex: number;
+            x: number;
+            width: number;
+            label: string;
+            showLabel: boolean;
+        }[];
+        total: number;
+        valueText: string;
+        datum: ChartDatum;
+        title: string;
+        groupY: number;
+    }[];
+    groups: (string | undefined)[];
+    pitch: number;
+    x: (v: number) => number;
+    scale: {
+        domain: [number, number];
+        ticks: number[];
+    };
+    format: (value: number) => string;
+    unit: number;
+    legend: {
+        hidden: number;
+        height: number;
+        items: {
+            label: string;
+            data: (number | null)[];
+            total: number | null;
+            x: number;
+            y: number;
+            labelWidth: number;
+            valueX: number;
+            valueText: string;
+            text: string;
+        }[];
+    };
+};
+export type HorizontalBarLayout = ReturnType<typeof hbarLayout>;

package/dist/types/charts/core/hbar.d.ts

@@ -0,0 +1,13 @@
+import { type HorizontalBarLayout, type HorizontalBarOptions } from "./hbar-layout";
+export { type HorizontalBarLayout, type HorizontalBarOptions, hbarLayout } from "./hbar-layout";
+export declare function renderHbarSvg(spec: HorizontalBarOptions & {
+    width: number;
+    height: number;
+    inspect?: boolean;
+}): string;
+/** Draw an already prepared layout; lazy hosts reuse the geometry reserved before loading. */
+export declare function renderHbarLayoutSvg(spec: HorizontalBarOptions & {
+    width: number;
+    height: number;
+    inspect?: boolean;
+}, g: HorizontalBarLayout): string;

package/dist/types/charts/core/index.d.ts

@@ -1,11 +1,21 @@
 /** Portable chart contracts. This entry never imports Solid or browser APIs. */
-export { type BarChartOptions, barChartLayout, renderBarChartSvg } from "../../content/chart-bar";
+export { type BarChartLayout, type BarChartOptions, barChartLayout, rankedBarLayout, renderBarChartSvg, seriesBarLayout, } from "../../content/chart-bar";
 export { renderStateTimelineSvg, type StateTimelineChartOptions, type StateTimelineDomain, stateTimelineDomain, stateTimelineHeight, } from "../../content/chart-state-timeline";
 export { type ChartTimeAxis } from "../../content/chart-time-axis";
 export { type AreaOptions, areaLayout, renderAreaSvg } from "./area";
+export * from "./bubble";
 export * from "./calendar";
+export { type FunnelLayout, type FunnelOptions, funnelLayout, renderFunnelLayoutSvg, renderFunnelSvg } from "./funnel";
+export { type HorizontalBarLayout, type HorizontalBarOptions, hbarLayout, renderHbarLayoutSvg, renderHbarSvg } from "./hbar";
 export * from "./inspection";
+export { map } from "./map";
+export * from "./pareto";
+export * from "./radar";
 export * from "./render";
+export { chartRenderHeight, preservesAspectRatio } from "./render-size";
 export * from "./snapshot";
-export { type AxisOptions, arcPathD, autoBin, type BarItem, bar, barGauge, boxplot, type ChartOptions, chartDatumSvg, charts, computeBoxStats, computeDomain, donut, escapeXml, extendDomainToNice, gauge, heatmap, histogram, type LineStyle, line, linearRegression, linePathD, type MapOptions, type MapPoint, type MapSeries, type MapViewport, type MarkerShape, map, mapLog, mapRange, markerPath, niceLogTicks, niceStep, normalizePadding, type Padding, type Point, pie, type ReferenceLine, type Series, type SliceItem, scatter, smoothPathD, sparkline, stat, stateTimeline, stepPathD, svgRoot, } from "./svg";
+export { charts } from "./svg";
+export { type AxisOptions, arcPathD, autoBin, type BarItem, bar, barGauge, boxplot, type ChartOptions, chartDatumSvg, computeBoxStats, computeDomain, donut, escapeXml, extendDomainToNice, gauge, heatmap, histogram, type LineStyle, line, linearRegression, linePathD, type MapOptions, type MapPoint, type MapSeries, type MapViewport, type MarkerShape, mapLog, mapRange, markerPath, niceLogTicks, niceStep, normalizePadding, type Padding, type Point, pie, type ReferenceLine, type Series, type SliceItem, scatter, smoothPathD, sparkline, stat, stateTimeline, stepPathD, svgRoot, } from "./svg-renderers";
+export * from "./treemap";
 export { type ChartDateFormat, type ChartDatum, type ChartDatumRole, type ChartFormat, type ChartKind, type ChartNumberFormat, chartDatumRoles, } from "./types";
+export { renderWaterfallLayoutSvg, renderWaterfallSvg, type WaterfallLayout, type WaterfallOptions, waterfallLayout } from "./waterfall";

package/dist/types/charts/core/map.d.ts

@@ -0,0 +1,3 @@
+import { type MapOptions } from "./svg-renderers";
+/** Render geographic point series over a dependency-free world land map. */
+export declare function map(opts: MapOptions): string;