@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/widgets/vertical/audit-log-data.js

@@ -0,0 +1,290 @@
+// widgets/vertical/audit-log-data.ts: the pure half of audit-log. It turns the
+// model's `entries` into rows the template only paints: plain text, a known
+// severity (or none), a deduped type, a unique key, a parsed time and a details
+// shape. Nothing here throws; bad items are skipped, bad fields degrade.
+//
+// Time is read with one regex, never `Date` parsing: YYYY-MM-DD, an optional
+// [T ]HH:MM[:SS[.sss]] and an optional zone (Z, UTC, GMT, +HH:MM, +HHMM). Day
+// keys and labels come from the written digits formatted in UTC, so an offset
+// never moves a row to another day, and an impossible day (2026-02-31) fails
+// the round trip and stays as written. Anything else is kept raw.
+//
+// Grouping keeps the model's row order inside a group, puts groups newest
+// first, and sends rows with no usable date to a last "No exact date" group.
+// When no row has a date, grouping is off.
+import { plain } from '../data-kit/format.js';
+import { safeArray, uniqueKeys } from '../../utils/safe-props.js';
+export const SEVERITIES = ['destructive', 'warning', 'success', 'info'];
+export const SEVERITY_WORD = {
+    destructive: 'Destructive',
+    warning: 'Warning',
+    success: 'Success',
+    info: 'Info'
+};
+export const SEVERITY_STATUS = {
+    destructive: 'bad',
+    warning: 'warn',
+    success: 'good',
+    info: 'info'
+};
+const SEVERITY_ALIAS = {
+    destructive: 'destructive',
+    error: 'destructive',
+    critical: 'destructive',
+    danger: 'destructive',
+    fatal: 'destructive',
+    warning: 'warning',
+    warn: 'warning',
+    success: 'success',
+    ok: 'success',
+    done: 'success',
+    info: 'info',
+    notice: 'info'
+};
+const ACTOR_ICON_KEYS = ['user', 'users', 'bot', 'cog', 'server', 'key', 'shield', 'mail'];
+/** `true` / `"true"` and `false` / `"false"`; anything else is the default. */
+export function flag(v, fallback) {
+    if (v === true || v === 'true')
+        return true;
+    if (v === false || v === 'false')
+        return false;
+    return fallback;
+}
+export function toSeverity(v) {
+    return typeof v === 'string' ? SEVERITY_ALIAS[v.trim().toLowerCase()] : undefined;
+}
+const STAMP = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::\d{2}(?:\.\d+)?)?(?:\s*(Z|UTC|GMT|[+-]\d{2}:?\d{2}))?)?$/i;
+export function parseStamp(v) {
+    const raw = typeof v === 'number' ? String(v) : plain(v);
+    const m = STAMP.exec(raw);
+    if (!m)
+        return { raw };
+    const [, y, mo, d, hh, mm, z] = m;
+    const day = `${y}-${mo}-${d}`;
+    const t = Date.UTC(+y, +mo - 1, +d);
+    if (new Date(t).toISOString().slice(0, 10) !== day)
+        return { raw };
+    if (hh !== undefined && (+hh > 23 || +mm > 59))
+        return { raw };
+    const out = { raw, day };
+    if (hh !== undefined)
+        out.time = `${hh}:${mm}`;
+    if (z)
+        out.zone = zoneName(z);
+    return out;
+}
+function zoneName(z) {
+    if (/^(z|utc|gmt)$/i.test(z))
+        return 'UTC';
+    const digits = z.replace(':', '');
+    if (/^[+-]0000$/.test(digits))
+        return 'UTC';
+    return `UTC${digits.slice(0, 3)}:${digits.slice(3)}`;
+}
+function utc(day) {
+    const [y, m, d] = day.split('-').map(Number);
+    return Date.UTC(y, m - 1, d);
+}
+function fmt(day, opts) {
+    return new Intl.DateTimeFormat('en-US', { ...opts, timeZone: 'UTC' }).format(utc(day));
+}
+/** "Sat, Mar 14, 2026" */
+export function dayHeading(day) {
+    return fmt(day, { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' });
+}
+/** "May 3" or, with year, "May 3, 2026". */
+export function monthDay(day, withYear = false) {
+    return fmt(day, withYear ? { month: 'short', day: 'numeric', year: 'numeric' } : { month: 'short', day: 'numeric' });
+}
+/** "May 3, 2026", "May 2 – 3, 2026", "Apr 28 – May 3, 2026", "Dec 29, 2025 – Jan 4, 2026". */
+export function dayRange(a, b) {
+    if (a === b)
+        return monthDay(a, true);
+    const [ya, ma] = a.split('-');
+    const [yb, mb] = b.split('-');
+    if (ya !== yb)
+        return `${monthDay(a, true)} – ${monthDay(b, true)}`;
+    if (ma !== mb)
+        return `${monthDay(a)} – ${monthDay(b, true)}`;
+    return `${monthDay(a)} – ${Number(b.slice(8))}, ${yb}`;
+}
+function addDays(day, n) {
+    return new Date(utc(day) + n * 86_400_000).toISOString().slice(0, 10);
+}
+/** The Monday that starts the week holding `day`. */
+export function weekStart(day) {
+    return addDays(day, -((new Date(utc(day)).getUTCDay() + 6) % 7));
+}
+export function weekHeading(monday) {
+    return dayRange(monday, addDays(monday, 6));
+}
+/** A plain object: not an array, not null. */
+function isRecord(v) {
+    return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+const ACRONYMS = new Set(['id', 'ip', 'url', 'uri', 'api', 'sso', 'mfa', 'ssh', 'dns', 'sku']);
+/** `approvedBy` → "Approved by", `request_id` → "Request ID", `api` → "API". Detail labels and types. */
+export function humanizeKey(k) {
+    const words = k
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[_-]+/g, ' ')
+        .trim()
+        .toLowerCase()
+        .split(/\s+/)
+        .map((w) => (ACRONYMS.has(w) ? w.toUpperCase() : w));
+    const s = words.join(' ');
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function scalar(v) {
+    return v === null || ['string', 'number', 'boolean'].includes(typeof v);
+}
+function show(v) {
+    if (v === null)
+        return 'None';
+    if (typeof v === 'boolean')
+        return v ? 'Yes' : 'No';
+    return typeof v === 'string' || typeof v === 'number' ? String(v) : json(v);
+}
+/** The details shape, or undefined when there is nothing to show. */
+export function toDetails(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (typeof v === 'string')
+        return v.trim() ? { kind: 'text', text: v.trim() } : undefined;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return { kind: 'text', text: String(v) };
+    if (Array.isArray(v))
+        return v.length ? { kind: 'json', text: json(v) } : undefined;
+    if (!isRecord(v))
+        return undefined;
+    const o = v;
+    const keys = Object.keys(o);
+    if (!keys.length)
+        return undefined;
+    if (!keys.every((k) => scalar(o[k])))
+        return { kind: 'json', text: json(o) };
+    const pair = 'from' in o && 'to' in o ? ['from', 'to'] : 'before' in o && 'after' in o ? ['before', 'after'] : undefined;
+    const change = pair
+        ? { from: show(o[pair[0]]), to: show(o[pair[1]]) }
+        : undefined;
+    const fields = keys
+        .filter((k) => !pair?.includes(k))
+        .map((k) => [humanizeKey(k), show(o[k])]);
+    return { kind: 'fields', change, fields };
+}
+function json(v) {
+    try {
+        return JSON.stringify(v) ?? '';
+    }
+    catch {
+        return String(v);
+    }
+}
+const BOT_NAME = /^(system|automation|scheduler)$|bot$/i;
+export function actorIconKey(name, explicit) {
+    const known = ACTOR_ICON_KEYS.find((k) => k === explicit);
+    if (known)
+        return known;
+    return BOT_NAME.test(name) ? 'bot' : undefined;
+}
+/** Model entries in, renderable rows out. Non-object items are skipped. */
+export function normalizeEntries(raw) {
+    const items = safeArray(raw, { widget: 'audit-log', key: 'entries' }).filter(isRecord);
+    const keys = uniqueKeys(items, (e, i) => (e.id === undefined || e.id === null || e.id === '' ? `row-${i}` : e.id));
+    return items.map((e, i) => {
+        const actor = plain(e.actor);
+        const id = typeof e.id === 'string' || typeof e.id === 'number' ? e.id : undefined;
+        return {
+            key: keys[i],
+            id,
+            actor,
+            actorIcon: actorIconKey(actor, e.actorIcon),
+            action: plain(e.action),
+            target: typeof e.target === 'number' ? String(e.target) : plain(e.target),
+            type: plain(e.type),
+            severity: toSeverity(e.severity),
+            stamp: parseStamp(e.timestamp),
+            details: toDetails(e.details)
+        };
+    });
+}
+/** Distinct values, compared case-insensitively, first spelling wins. */
+export function facets(values) {
+    const seen = new Map();
+    for (const v of values)
+        if (v && !seen.has(v.toLowerCase()))
+            seen.set(v.toLowerCase(), v);
+    return [...seen.values()];
+}
+/** Grouping is on only for day/week with at least one dated row. */
+export function effectiveGroupBy(rows, groupBy) {
+    if (groupBy !== 'day' && groupBy !== 'week')
+        return 'none';
+    return rows.some((r) => r.stamp.day) ? groupBy : 'none';
+}
+export function groupEntries(rows, groupBy) {
+    if (groupBy === 'none')
+        return [{ key: 'all', label: '', rows }];
+    const map = new Map();
+    const undated = [];
+    for (const r of rows) {
+        if (!r.stamp.day) {
+            undated.push(r);
+            continue;
+        }
+        const k = groupBy === 'day' ? r.stamp.day : weekStart(r.stamp.day);
+        map.set(k, [...(map.get(k) ?? []), r]);
+    }
+    const groups = [...map.keys()]
+        .sort((a, b) => (a < b ? 1 : a > b ? -1 : 0))
+        .map((k) => ({ key: k, label: groupBy === 'day' ? dayHeading(k) : weekHeading(k), rows: map.get(k) }));
+    if (undated.length)
+        groups.push({ key: 'undated', label: 'No exact date', rows: undated });
+    return groups;
+}
+/** One zone shared by every timed row ("UTC"), or undefined when mixed or absent. */
+export function sharedZone(rows) {
+    const zones = new Set(rows.filter((r) => r.stamp.time).map((r) => r.stamp.zone));
+    if (zones.size !== 1)
+        return undefined;
+    return [...zones][0];
+}
+/** True when timed rows disagree on zone, so each row names its own. */
+export function mixedZones(rows) {
+    return new Set(rows.filter((r) => r.stamp.time).map((r) => r.stamp.zone ?? '')).size > 1;
+}
+/**
+ * The row's time slot: "14:32" inside a day group, "May 3, 14:32" otherwise,
+ * the date alone for a date-only stamp, the raw text when it did not parse.
+ */
+export function rowTime(s, opts) {
+    if (!s.day)
+        return s.raw;
+    const zone = opts.withZone && s.zone ? ` ${s.zone}` : '';
+    const time = s.time ? `${s.time}${zone}` : '';
+    if (opts.inDay)
+        return time;
+    const date = monthDay(s.day, opts.withYear);
+    return time ? `${date}, ${time}` : date;
+}
+/** For screen readers: "May 3 at 13:15 UTC". */
+export function spokenTime(s) {
+    if (!s.day)
+        return s.raw;
+    return s.time ? `${monthDay(s.day)} at ${s.time}${s.zone ? ` ${s.zone}` : ''}` : monthDay(s.day);
+}
+/** "4 events · May 2 – 3, 2026 · times in UTC" */
+export function summaryLine(rows) {
+    const parts = [`${rows.length} ${rows.length === 1 ? 'event' : 'events'}`];
+    const days = rows.map((r) => r.stamp.day).filter((d) => !!d).sort();
+    if (days.length)
+        parts.push(dayRange(days[0], days[days.length - 1]));
+    const zone = sharedZone(rows);
+    if (zone)
+        parts.push(`times in ${zone}`);
+    return parts.join(' · ');
+}
+/** "a / b" target pieces with a break opportunity after / : . @ - */
+export function breakable(s) {
+    return s.split(/(?<=[/:.@-])/);
+}

package/dist/widgets/vertical/bulk-action-bar.d.ts

@@ -0,0 +1,37 @@
+export type BulkAction = {
+    id: string;
+    label: string;
+    icon?: string;
+    destructive: boolean;
+    disabled: boolean;
+};
+/** Container width (px) at and above which the bar is one row. */
+export declare const WIDE_AT = 520;
+/** A whole, positive selection count, or 0 (the bar then renders nothing). */
+export declare function sanitizeCount(v: unknown): number;
+/** "1 category", "12,480 categories", "1,000,000 boxes": three rules on the last word. */
+export declare function countLabel(count: number, noun: unknown): {
+    count: string;
+    rest: string;
+};
+export declare function pluralize(word: string): string;
+/** Drop blank labels, fall back id to label, and move destructive actions last. */
+export declare function normalizeActions(v: unknown): BulkAction[];
+/**
+ * Which actions sit in the row and which go to More. `width` is the bar's own
+ * width (0 = not measured, SSR or jsdom: the wide rule with no budget),
+ * `leadChars` the length of the count line and `wordChars` its longest word.
+ *
+ * Both sizes hold at most 4 controls, so 3 actions plus More whenever anything
+ * overflows; a disabled action keeps its slot.
+ * Wide (>= WIDE_AT): labels up to 24 characters, in order, while their
+ * estimated width fits beside the count. The count shrinks and wraps first: it
+ * is budgeted only a quarter of the bar (or its longest word, if wider), so a
+ * wider bar never shows fewer actions than the narrow one.
+ * Narrow: labels up to 14 characters whose longest word fits a quarter-width
+ * column.
+ */
+export declare function splitActions(actions: BulkAction[], width?: number, leadChars?: number, wordChars?: number): {
+    inline: BulkAction[];
+    menu: BulkAction[];
+};

package/dist/widgets/vertical/bulk-action-bar.js

@@ -0,0 +1,105 @@
+// widgets/vertical/bulk-action-bar.ts: the pure half of BulkActionBar. Props are
+// model output, so the count, noun and actions are normalised here before the
+// component sees them, and the inline-versus-More split is a fixed rule on label
+// length, an estimated width per character and the bar's measured width (no
+// measuring of rendered text). Everything here returns a value and never throws.
+import { asText } from '@ripple-ui/core';
+import { finite, num } from '../data-kit/format.js';
+import { safeArray } from '../../utils/safe-props.js';
+/** Container width (px) at and above which the bar is one row. */
+export const WIDE_AT = 520;
+/** A whole, positive selection count, or 0 (the bar then renders nothing). */
+export function sanitizeCount(v) {
+    const n = finite(v);
+    return n === undefined ? 0 : Math.max(0, Math.round(n));
+}
+/** "1 category", "12,480 categories", "1,000,000 boxes": three rules on the last word. */
+export function countLabel(count, noun) {
+    const word = asText(noun).trim() || 'item';
+    return { count: num(count, { digits: 0 }), rest: `${count === 1 ? word : pluralize(word)} selected` };
+}
+export function pluralize(word) {
+    if (/[^aeiou]y$/i.test(word))
+        return word.slice(0, -1) + 'ies';
+    if (/(s|x|z|ch|sh)$/i.test(word))
+        return word + 'es';
+    return word + 's';
+}
+/** Drop blank labels, fall back id to label, and move destructive actions last. */
+export function normalizeActions(v) {
+    const out = [];
+    for (const raw of safeArray(v, { widget: 'bulk-action-bar', key: 'actions' })) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const label = asText(raw.label).trim();
+        if (!label)
+            continue;
+        const icon = typeof raw.icon === 'string' ? raw.icon : undefined;
+        out.push({
+            id: asText(raw.id).trim() || label,
+            label,
+            icon,
+            destructive: raw.variant === 'destructive',
+            disabled: raw.disabled === true
+        });
+    }
+    return [...out.filter((a) => !a.destructive), ...out.filter((a) => a.destructive)];
+}
+// Estimated pixel costs at the bar's sizes (13px labels at about 7px a character;
+// 12px narrow labels at about 6.5px). Estimates only: the wide row is nowrap, so a
+// miss shows up as an overflow in the audit rather than a silent wrap.
+const CH = 7;
+const BTN = 44; // 8px padding each side, 16px icon, 6px icon gap, 6px row gap
+const MORE = BTN + 4 * CH;
+const DIVIDER = 13;
+const ROW_CHROME = 28; // bar padding, border, and the gap between count and actions
+const NARROW_CH = 6.5;
+/**
+ * Which actions sit in the row and which go to More. `width` is the bar's own
+ * width (0 = not measured, SSR or jsdom: the wide rule with no budget),
+ * `leadChars` the length of the count line and `wordChars` its longest word.
+ *
+ * Both sizes hold at most 4 controls, so 3 actions plus More whenever anything
+ * overflows; a disabled action keeps its slot.
+ * Wide (>= WIDE_AT): labels up to 24 characters, in order, while their
+ * estimated width fits beside the count. The count shrinks and wraps first: it
+ * is budgeted only a quarter of the bar (or its longest word, if wider), so a
+ * wider bar never shows fewer actions than the narrow one.
+ * Narrow: labels up to 14 characters whose longest word fits a quarter-width
+ * column.
+ */
+export function splitActions(actions, width = 0, leadChars = 0, wordChars = 0) {
+    if (width > 0 && width < WIDE_AT) {
+        const maxWord = Math.floor(((width - ROW_CHROME) / 4 - 8) / NARROW_CH);
+        const max = actions.length >= 5 ? 3 : 4;
+        const fits = (a) => a.label.length <= 14 && a.label.split(/\s+/).every((w) => w.length <= maxWord);
+        const inline = [];
+        const menu = [];
+        for (const a of actions)
+            (inline.length < max && fits(a) ? inline : menu).push(a);
+        return { inline, menu };
+    }
+    const room = width === 0 ? Infinity : width - ROW_CHROME - (36 + CH * Math.min(leadChars, Math.max(wordChars, (width / 4 - 36) / CH)));
+    const all = pack(actions, room, 4);
+    return all.menu.length ? pack(actions, room - MORE, 3) : all;
+}
+/** Up to `max` labels of 24 characters or fewer, in order, until the budget runs out. */
+function pack(actions, budget, max) {
+    const inline = [];
+    const menu = [];
+    let used = 0;
+    let full = false;
+    for (const a of actions) {
+        const cost = BTN + a.label.length * CH + (a.destructive && !inline.some((b) => b.destructive) ? DIVIDER : 0);
+        if (!full && inline.length < max && a.label.length <= 24) {
+            if (used + cost <= budget) {
+                inline.push(a);
+                used += cost;
+                continue;
+            }
+            full = true;
+        }
+        menu.push(a);
+    }
+    return { inline, menu };
+}

package/dist/widgets/vertical/index.d.ts

@@ -0,0 +1,11 @@
+export { default as PricingTable } from './PricingTable.svelte';
+export { default as SettingsList } from './SettingsList.svelte';
+export { default as CommentThread } from './CommentThread.svelte';
+export { default as AuditLog } from './AuditLog.svelte';
+export { default as ApiKey } from './ApiKey.svelte';
+export { default as BulkActionBar } from './BulkActionBar.svelte';
+export { default as SavedViews } from './SavedViews.svelte';
+export { default as PeoplePicker } from './PeoplePicker.svelte';
+export { default as PermissionMatrix } from './PermissionMatrix.svelte';
+export { default as OrgChart } from './OrgChart.svelte';
+export { default as InvoiceLines } from './InvoiceLines.svelte';

package/dist/widgets/vertical/index.js

@@ -0,0 +1,11 @@
+export { default as PricingTable } from './PricingTable.svelte';
+export { default as SettingsList } from './SettingsList.svelte';
+export { default as CommentThread } from './CommentThread.svelte';
+export { default as AuditLog } from './AuditLog.svelte';
+export { default as ApiKey } from './ApiKey.svelte';
+export { default as BulkActionBar } from './BulkActionBar.svelte';
+export { default as SavedViews } from './SavedViews.svelte';
+export { default as PeoplePicker } from './PeoplePicker.svelte';
+export { default as PermissionMatrix } from './PermissionMatrix.svelte';
+export { default as OrgChart } from './OrgChart.svelte';
+export { default as InvoiceLines } from './InvoiceLines.svelte';

package/dist/widgets/vertical/invoice-math.d.ts

@@ -0,0 +1,39 @@
+export type InvoiceLine = {
+    id?: string | number;
+    description?: string;
+    quantity?: number | string;
+    unitPrice?: number | string;
+    total?: number | string;
+    amount?: number | string;
+    note?: string;
+};
+export type SummaryRow = {
+    label?: string;
+    value?: number | string;
+    amount?: number | string;
+    total?: number | string;
+    isNegative?: boolean;
+};
+export declare function lineAmount(l: InvoiceLine): number | undefined;
+export declare function summaryValue(s: SummaryRow): number | undefined;
+export declare const isSubtotalRow: (s: SummaryRow) => boolean;
+export declare const isTotalRow: (s: SummaryRow) => boolean;
+export type InvoiceTotals = {
+    subtotal: number;
+    subtotalLabel: string;
+    /** Sum of the lines, set only when every line has an amount and it differs from `subtotal`. */
+    linesAddTo?: number;
+    extras: SummaryRow[];
+    total: number;
+    /** Subtotal plus extras, set only when the shown total differs from it. */
+    rowsAddTo?: number;
+};
+export declare function invoiceTotals(input: {
+    lines: InvoiceLine[];
+    summary?: SummaryRow[];
+    subtotal?: unknown;
+    total?: unknown;
+}): InvoiceTotals;
+/** Money for display: a symbol prefix ("$") or an ISO code ("USD") through Intl.
+ *  Negatives carry a true minus tight to the symbol; unknown is a dash. */
+export declare function formatAmount(n: number | undefined, currency?: string): string;

package/dist/widgets/vertical/invoice-math.js

@@ -0,0 +1,67 @@
+// src/lib/widgets/vertical/invoice-math.ts: the arithmetic behind
+// invoice-lines and the invoice-layout hero, in one place so the hero amount
+// and the table's Total can never disagree.
+//
+// Amounts are model output. A line reads `total`, then `amount`, then
+// quantity x unitPrice (numeric strings count); with none of those it is
+// unknown (undefined), shows a dash and stays out of the sum. A summary row
+// reads `value`, then `amount`, then `total`.
+//
+// The model's figures win: an explicit `subtotal` / `total` prop, else a
+// summary row labelled like "Subtotal" / "Total" stands in for that row and
+// never prints as an extra. When a shown figure disagrees with what its rows
+// add to (0.01 or more), the result carries the sum so the table can say so.
+import { finite, money } from '../data-kit/format.js';
+export function lineAmount(l) {
+    const t = finite(l?.total) ?? finite(l?.amount);
+    if (t !== undefined)
+        return t;
+    const q = finite(l?.quantity);
+    const u = finite(l?.unitPrice);
+    return q !== undefined && u !== undefined ? q * u : undefined;
+}
+export function summaryValue(s) {
+    const v = finite(s?.value) ?? finite(s?.amount) ?? finite(s?.total);
+    return v === undefined ? undefined : s.isNegative ? -Math.abs(v) : v;
+}
+const label = (s) => String(s?.label ?? '').trim();
+export const isSubtotalRow = (s) => /subtotal/i.test(label(s));
+// Checked after the subtotal rule, so "Subtotal" never lands here.
+export const isTotalRow = (s) => !isSubtotalRow(s) && /^(grand\s+)?total(\s+due)?$|^amount\s+due$/i.test(label(s));
+const differs = (a, b) => Math.abs(a - b) >= 0.0099;
+export function invoiceTotals(input) {
+    const summary = input.summary ?? [];
+    const amounts = input.lines.map(lineAmount);
+    const lineSum = amounts.reduce((acc, n) => acc + (n ?? 0), 0);
+    const allKnown = amounts.every((n) => n !== undefined);
+    const subRow = summary.find(isSubtotalRow);
+    const totalRow = summary.find(isTotalRow);
+    const extras = summary.filter((s) => !isSubtotalRow(s) && !isTotalRow(s));
+    const explicitSub = finite(input.subtotal);
+    const subtotal = explicitSub ?? (subRow ? summaryValue(subRow) : undefined) ?? lineSum;
+    const subtotalLabel = explicitSub === undefined && subRow && label(subRow) ? label(subRow) : 'Subtotal';
+    const rowsSum = subtotal + extras.reduce((acc, s) => acc + (summaryValue(s) ?? 0), 0);
+    const shownTotal = finite(input.total) ?? (totalRow ? summaryValue(totalRow) : undefined);
+    const total = shownTotal ?? rowsSum;
+    return {
+        subtotal,
+        subtotalLabel,
+        linesAddTo: allKnown && input.lines.length > 0 && differs(subtotal, lineSum) ? lineSum : undefined,
+        extras,
+        total,
+        rowsAddTo: shownTotal !== undefined && differs(shownTotal, rowsSum) ? rowsSum : undefined,
+    };
+}
+/** Money for display: a symbol prefix ("$") or an ISO code ("USD") through Intl.
+ *  Negatives carry a true minus tight to the symbol; unknown is a dash. */
+export function formatAmount(n, currency = '$') {
+    if (n === undefined || !Number.isFinite(n))
+        return '—';
+    if (/^[A-Za-z]{3}$/.test(currency))
+        return money(n, currency).replace(/^-/, '−');
+    const sign = n < 0 ? '−' : '';
+    return `${sign}${currency}${Math.abs(n).toLocaleString(undefined, {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2,
+    })}`;
+}

package/dist/widgets/vertical/org-chart-layout.d.ts

@@ -0,0 +1,52 @@
+export type Id = string | number;
+export type Mode = 'tree' | 'stacked' | 'list';
+export type Person = {
+    key: string;
+    /** Original id, or undefined when missing (shown, never selectable). */
+    id: Id | undefined;
+    /** Display name; 'Unnamed' when empty. */
+    name: string;
+    unnamed: boolean;
+    title: string;
+    /** A safe URL, or undefined (initials then). */
+    avatar: string | undefined;
+    children: Person[];
+    /** People below this one cut by the depth guard. */
+    more: number;
+    depth: number;
+};
+export declare const CARD_W = 152;
+export declare const GAP = 16;
+export declare const UNIT: number;
+/** A stacked team's column sits this far right of its manager's card. */
+export declare const STACK_INDENT = 16;
+export declare const MAX_DEPTH = 16;
+export declare const CHART_MAX_PEOPLE = 24;
+export declare const CHART_MIN_WIDTH = 480;
+export declare const MAX_STACK = 8;
+/** List rows stop indenting past this many levels below the root. */
+export declare const LIST_INDENT_CAP = 5;
+/** The model's `root` as a forest: [] when empty, several roots for an array. */
+export declare function normalize(root: unknown): Person[];
+export declare function stats(forest: Person[]): {
+    people: number;
+    levels: number;
+    cut: boolean;
+};
+export declare function summary(forest: Person[]): string;
+/** A manager whose two or more reports are all leaves: one column in `stacked`. */
+export declare function isStack(p: Person): boolean;
+/** Columns a subtree needs in a chart mode. */
+export declare function columns(p: Person, mode: 'tree' | 'stacked'): number;
+/** Width in px a subtree takes when drawn; the component sets exactly this. */
+export declare function nodeWidth(p: Person, mode: 'tree' | 'stacked'): number;
+/** The first layout that fits `width` px of content. 0 (not measured yet) is `list`. */
+export declare function pickMode(forest: Person[], width: number): Mode;
+/** Keys from the root down to the selected person (inclusive), or []. */
+export declare function selectedPath(forest: Person[], value: unknown): string[];
+/**
+ * Managers open by default in the list: all of them up to CHART_MAX_PEOPLE;
+ * past that the roots and their direct reports, plus every ancestor of the
+ * selected person.
+ */
+export declare function defaultOpen(forest: Person[], path: string[]): Set<string>;