@calliopelabs/ui 0.13.0 → 0.14.0

package/dist/chat/useAgUiRun.js

@@ -0,0 +1,137 @@
+"use client";
+import { EventType } from "@ag-ui/core";
+import * as React from "react";
+import { createChatView, foldChat, reduceChat } from "./model.js";
+/** The person's own message as the events that fold it into the view. */
+export function userMessageEvents(id, text) {
+    return [
+        { type: EventType.TEXT_MESSAGE_START, messageId: id, role: "user" },
+        { type: EventType.TEXT_MESSAGE_CONTENT, messageId: id, delta: text },
+        { type: EventType.TEXT_MESSAGE_END, messageId: id },
+    ];
+}
+const message = (error) => error instanceof Error && error.message
+    ? error.message
+    : typeof error === "string" && error
+        ? error
+        : "The event stream failed.";
+/**
+ * Holds a `ChatView` and folds a host-provided AG-UI event source into it,
+ * one run at a time. No network code: the host connects, authenticates and
+ * sends input, and hands the hook what comes back.
+ *
+ *   const chat = useAgUiRun();
+ *   onSubmit={(text) => {
+ *     chat.dispatch(userMessageEvents(id(), text));
+ *     void chat.run(agent.stream({ threadId, text }));
+ *   }}
+ */
+export function useAgUiRun({ initialView, onError } = {}) {
+    const [view, setView] = React.useState(() => initialView ?? createChatView());
+    const [running, setRunning] = React.useState(false);
+    const current = React.useRef(null);
+    const onErrorRef = React.useRef(onError);
+    React.useEffect(() => {
+        onErrorRef.current = onError;
+    });
+    const release = React.useCallback(() => {
+        const active = current.current;
+        current.current = null;
+        active?.release();
+    }, []);
+    React.useEffect(() => release, [release]);
+    const run = React.useCallback((source) => {
+        release();
+        let live = true;
+        let cleanup = () => { };
+        let stopped = () => { };
+        const halted = new Promise((resolve) => {
+            stopped = () => resolve("stopped");
+        });
+        const token = {
+            release: () => {
+                live = false;
+                cleanup();
+                stopped();
+            },
+        };
+        current.current = token;
+        setRunning(true);
+        const fold = (event) => {
+            if (live)
+                setView((v) => reduceChat(v, event));
+        };
+        const end = (error) => {
+            if (!live)
+                return;
+            live = false;
+            if (current.current === token)
+                current.current = null;
+            if (error !== undefined) {
+                setView((v) => reduceChat(v, { type: EventType.RUN_ERROR, message: message(error) }));
+                onErrorRef.current?.(error);
+            }
+            setRunning(false);
+        };
+        if (typeof source === "function") {
+            let finished = () => { };
+            const ended = new Promise((resolve) => {
+                finished = resolve;
+            });
+            try {
+                const unsubscribe = source(fold, (error) => {
+                    end(error);
+                    finished();
+                });
+                if (live)
+                    cleanup = unsubscribe;
+                else
+                    unsubscribe();
+            }
+            catch (error) {
+                end(error);
+                finished();
+            }
+            return Promise.race([ended, halted]).then(() => { });
+        }
+        return (async () => {
+            try {
+                const iterator = source[Symbol.asyncIterator]();
+                cleanup = () => void iterator.return?.()?.catch(() => { });
+                for (;;) {
+                    const next = await Promise.race([iterator.next(), halted]);
+                    if (next === "stopped" || next.done)
+                        break;
+                    fold(next.value);
+                }
+                end();
+            }
+            catch (error) {
+                end(error);
+            }
+        })();
+    }, [release]);
+    const stop = React.useCallback(() => {
+        if (!current.current)
+            return;
+        release();
+        setRunning(false);
+        setView((v) => v.status === "running"
+            ? reduceChat(v, {
+                type: EventType.RUN_FINISHED,
+                threadId: v.threadId ?? "",
+                runId: v.runId ?? "",
+                outcome: { type: "cancelled" },
+            })
+            : v);
+    }, [release]);
+    const dispatch = React.useCallback((events) => {
+        setView((v) => foldChat(Array.isArray(events) ? events : [events], v));
+    }, []);
+    const reset = React.useCallback((next) => {
+        release();
+        setRunning(false);
+        setView(next ?? createChatView());
+    }, [release]);
+    return { view, running, run, stop, dispatch, reset };
+}

package/dist/index.d.ts

@@ -90,3 +90,12 @@ export { documentStatus, type WorkflowDocumentStatus, type WorkflowRevision, } f
 export { WorkflowDiff, type WorkflowDiffProps } from "./workflow/editor/WorkflowDiff.js";
 export { WorkflowImportPreview, type WorkflowImportPreviewProps, } from "./workflow/editor/WorkflowImportPreview.js";
 export { WorkflowWorkspace, type WorkflowWorkspaceProps, } from "./workflow/editor/WorkflowWorkspace.js";
+export { contentText, createChatView, foldChat, isChatRunning, parseToolCallArgs, reduceChat, type AgUiEvent, type AgUiInterrupt, type ChatApproval, type ChatMessage, type ChatRole, type ChatRunStatus, type ChatStep, type ChatStepStatus, type ChatTimelineItem, type ChatToolCall, type ChatToolCallStatus, type ChatView, } from "./chat/model.js";
+export { applyJsonPatch } from "./chat/patch.js";
+export { MessageBubble, type ChatContentRenderer, type MessageBubbleProps, } from "./chat/MessageBubble.js";
+export { MessageList, type MessageListProps } from "./chat/MessageList.js";
+export { Composer, type ComposerProps } from "./chat/Composer.js";
+export { ToolCallCard, type ToolCallCardProps } from "./chat/ToolCallCard.js";
+export { AgentProgress, CHAT_RUN_TONE, chatStepStages, type AgentProgressProps, } from "./chat/AgentProgress.js";
+export { ModelPicker, type ModelPickerProps } from "./chat/ModelPicker.js";
+export { useAgUiRun, userMessageEvents, type AgUiEventSource, type AgUiRun, type AgUiSubscribe, type UseAgUiRunOptions, } from "./chat/useAgUiRun.js";

package/dist/index.js

@@ -99,3 +99,13 @@ export { documentStatus, } from "./workflow/workspace.js";
 export { WorkflowDiff } from "./workflow/editor/WorkflowDiff.js";
 export { WorkflowImportPreview, } from "./workflow/editor/WorkflowImportPreview.js";
 export { WorkflowWorkspace, } from "./workflow/editor/WorkflowWorkspace.js";
+// Chat (AG-UI)
+export { contentText, createChatView, foldChat, isChatRunning, parseToolCallArgs, reduceChat, } from "./chat/model.js";
+export { applyJsonPatch } from "./chat/patch.js";
+export { MessageBubble, } from "./chat/MessageBubble.js";
+export { MessageList } from "./chat/MessageList.js";
+export { Composer } from "./chat/Composer.js";
+export { ToolCallCard } from "./chat/ToolCallCard.js";
+export { AgentProgress, CHAT_RUN_TONE, chatStepStages, } from "./chat/AgentProgress.js";
+export { ModelPicker } from "./chat/ModelPicker.js";
+export { useAgUiRun, userMessageEvents, } from "./chat/useAgUiRun.js";

package/dist/primitives/Button.d.ts

@@ -6,7 +6,7 @@ import type * as React from "react";
  * reaches buttons as it reaches panels.
  */
 export declare const buttonVariants: (props?: ({
-    variant?: "link" | "default" | "outline" | "secondary" | "ghost" | "destructive" | null | undefined;
+    variant?: "destructive" | "link" | "default" | "outline" | "secondary" | "ghost" | null | undefined;
     size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ComponentProps<"button">, VariantProps<typeof buttonVariants> {

package/dist/provider/messages.d.ts

@@ -1,4 +1,5 @@
 import type { ProductTheme } from "../appearance/product.js";
+import type { ChatRole, ChatRunStatus, ChatToolCallStatus } from "../chat/model.js";
 import type { WorkflowQuestionState } from "../workflow/question.js";
 import type { WorkflowAction, WorkflowAvailability, WorkflowScope, WorkflowStatus } from "../workflow/model.js";
 import type { ArtifactStatus, GateStatus, ReviewDecision, ReviewVerdict, RunStageStatus } from "../workflow/run.js";
@@ -550,6 +551,71 @@ export interface Messages {
         /** A field extraction found nothing in. */
         empty: string;
     };
+    chat: {
+        /** The message list's name. */
+        conversation: string;
+        empty: string;
+        emptyDescription: string;
+        /** Who said it: "You", "Assistant", "System", "Developer", "Tool". */
+        role: (role: ChatRole) => string;
+        /** A message's accessible name. */
+        messageFrom: (speaker: string) => string;
+        /** An answer that has started but has no text yet. */
+        thinking: string;
+        /** Read after a message still being written. */
+        writing: string;
+        jumpToLatest: string;
+        runFailed: string;
+        retry: string;
+        /** The composer's field. */
+        composer: string;
+        placeholder: string;
+        composerHint: string;
+        send: string;
+        stop: string;
+        attachments: string;
+        /** A tool call's accessible name. */
+        toolCall: (name: string) => string;
+        toolStatus: (status: ChatToolCallStatus | "approval") => string;
+        details: string;
+        arguments: string;
+        noArguments: string;
+        result: string;
+        toolError: string;
+        approvalNeeded: string;
+        approve: string;
+        deny: string;
+        approveTitle: (name: string) => string;
+        approveDescription: string;
+        denyTitle: (name: string) => string;
+        denyDescription: string;
+        denyReason: string;
+        /** The agent progress section's name. */
+        progress: string;
+        steps: string;
+        runStatus: (status: ChatRunStatus) => string;
+        model: string;
+    };
+    agent: {
+        /** The assistant's name: the panel's title and the launcher's. Takes the product's name when there is one. */
+        title: (product?: string) => string;
+        /** The launcher's name when closed and open. */
+        open: (title: string) => string;
+        close: string;
+        /** Read with the launcher's name: "2 unread". */
+        unread: (count: number) => string;
+        newConversation: string;
+        expand: string;
+        restore: string;
+        /** The suggestion chips' group. */
+        suggestions: string;
+        emptyTitle: string;
+        emptyDescription: string;
+        /** Under the composer while a tool waits on the person. */
+        waitingOnYou: string;
+        /** The shortcut as people read it, from the key list ("⌘/", "Ctrl+/"). */
+        shortcut: (keys: string) => string;
+    };
 }
 export declare const defaultMessages: Messages;
 /** Any subset of the messages, one level deep. */

package/dist/provider/messages.js

@@ -781,6 +781,77 @@ export const defaultMessages = {
         cancel: "Cancel",
         empty: "Nothing found",
     },
+    chat: {
+        conversation: "Conversation",
+        empty: "No messages yet",
+        emptyDescription: "Ask a question to start.",
+        role: (role) => ({
+            user: "You",
+            assistant: "Assistant",
+            system: "System",
+            developer: "Developer",
+            tool: "Tool",
+        })[role],
+        messageFrom: (speaker) => `Message from ${speaker}`,
+        thinking: "Thinking",
+        writing: "Still writing",
+        jumpToLatest: "Jump to latest",
+        runFailed: "The run failed",
+        retry: "Retry",
+        composer: "Message",
+        placeholder: "Ask anything",
+        composerHint: "Enter to send, Shift+Enter for a new line.",
+        send: "Send",
+        stop: "Stop",
+        attachments: "Attachments",
+        toolCall: (name) => `Tool call ${name}`,
+        toolStatus: (status) => ({
+            streaming: "preparing",
+            running: "running",
+            complete: "done",
+            failed: "failed",
+            cancelled: "cancelled",
+            approval: "needs approval",
+        })[status],
+        details: "Details",
+        arguments: "Arguments",
+        noArguments: "No arguments",
+        result: "Result",
+        toolError: "Error",
+        approvalNeeded: "The agent is waiting for your approval to run this.",
+        approve: "Approve",
+        deny: "Deny",
+        approveTitle: (name) => `Run ${name}?`,
+        approveDescription: "The agent runs it with the arguments shown and continues.",
+        denyTitle: (name) => `Deny ${name}?`,
+        denyDescription: "The agent does not run it and is told why.",
+        denyReason: "Reason",
+        progress: "Agent progress",
+        steps: "Steps",
+        runStatus: (status) => ({
+            idle: "idle",
+            running: "running",
+            finished: "finished",
+            interrupted: "waiting for you",
+            cancelled: "stopped",
+            error: "failed",
+        })[status],
+        model: "Model",
+    },
+    agent: {
+        title: (product) => (product ? `${product} assistant` : "Assistant"),
+        open: (title) => `Open ${title}`,
+        close: "Close",
+        unread: (count) => `${count.toLocaleString("en")} unread`,
+        newConversation: "New conversation",
+        expand: "Expand",
+        restore: "Restore",
+        suggestions: "Suggestions",
+        emptyTitle: "How can I help?",
+        emptyDescription: "Ask about what is on this page, or pick a starting point.",
+        waitingOnYou: "Answer the card above to continue.",
+        shortcut: (keys) => `Shortcut ${keys}`,
+    },
 };
 export function mergeMessages(overrides) {
     if (!overrides)

package/dist/theme/mappings/palette.d.ts

@@ -0,0 +1,52 @@
+import { ACCENT_KEYS, DEFAULT_ACCENT, GROUNDS, GROUND_KEYS, type FamilyAccent, type Ground, type StatusName } from "../tokens.js";
+export declare const COLOR_TOKENS: readonly ["background", "foreground", "card", "card-foreground", "popover", "popover-foreground", "primary", "primary-foreground", "secondary", "secondary-foreground", "muted", "muted-foreground", "accent", "accent-foreground", "destructive", "border", "input", "ring", "chart-1", "chart-2", "chart-3", "chart-4", "chart-5", "sidebar", "sidebar-foreground", "sidebar-primary", "sidebar-primary-foreground", "sidebar-accent", "sidebar-accent-foreground", "sidebar-border", "sidebar-ring", "sidebar-muted-foreground", "surface-0", "surface-1", "surface-2", ...(StatusName | "success-fg" | "warning-fg" | "info-fg" | "danger-fg" | "success-bg" | "warning-bg" | "info-bg" | "danger-bg" | "success-border" | "warning-border" | "info-border" | "danger-border")[]];
+export type ColorToken = (typeof COLOR_TOKENS)[number];
+export type Palette = Record<ColorToken, string>;
+export { ACCENT_KEYS, DEFAULT_ACCENT, GROUNDS, GROUND_KEYS };
+export type { FamilyAccent, Ground };
+/** The ground `:root` paints when nothing chooses one (the preset's default). */
+export declare const DEFAULT_GROUND: Ground;
+/**
+ * The type stacks of the preset (`--font-sans`, `--font-mono`, `--font-head`
+ * in preset.css; a test holds them equal). Each names the app's loaded font
+ * variable first, then the family, then system fallbacks.
+ */
+export declare const FONTS: {
+    readonly sans: "var(--font-plex-sans, \"IBM Plex Sans\"), system-ui, sans-serif";
+    readonly mono: "var(--font-plex-mono, \"IBM Plex Mono\"), ui-monospace, SFMono-Regular, Menlo, monospace";
+    readonly head: "var(--font-dm-sans, \"DM Sans\"), system-ui, sans-serif";
+};
+/** The family a stack names, for targets that take one font name (React Native). */
+export declare function fontFamily(stack: string): string;
+/** `--radius` in px, and the motion durations in ms, as numbers. */
+export declare function staticNumbers(): {
+    radius: number;
+    motion: Record<"fast" | "base" | "slow", number>;
+};
+export interface Rgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** Parses `#rrggbb` or `rgba(r, g, b, a)`; anything else is a token this module does not know. */
+export declare function parseColor(value: string): Rgba;
+/**
+ * A translucent token laid on its surface, for targets with no alpha
+ * (a terminal, Tk): `sidebar-*` tokens on the sidebar, the rest on the
+ * background. Opaque tokens come back as they are.
+ */
+export declare function flatten(palette: Palette, token: ColorToken): Rgba;
+/** The concrete palette of one ground with one family accent, with no product brand. */
+export declare function resolvePalette(ground: Ground, accent?: FamilyAccent): Palette;
+/** Every ground with every family accent. */
+export declare function allPalettes(): Record<Ground, Record<FamilyAccent, Palette>>;
+/**
+ * A target's values split for compact output: per ground, the entries every
+ * accent agrees on, and per ground and accent, the entries that move with
+ * the accent.
+ */
+export declare function splitByAccent<K extends string, V>(values: (ground: Ground, accent: FamilyAccent) => Record<K, V>): {
+    ground: Record<Ground, Partial<Record<K, V>>>;
+    accent: Record<Ground, Record<FamilyAccent, Partial<Record<K, V>>>>;
+};

package/dist/theme/mappings/palette.js

@@ -0,0 +1,208 @@
+import { ACCENTS, ACCENT_KEYS, DEFAULT_ACCENT, GROUNDS, GROUND_KEYS, MODE_TOKENS, STATIC_TOKENS, SURFACES, } from "../tokens.js";
+/**
+ * The palette a page paints on one ground with one family accent, as
+ * concrete colours: what the preset's custom properties compute to on that
+ * page with no product brand set. Every token mapping (JupyterLab, VS Code,
+ * Python, React Native, plain CSS) is generated from this, and a test holds
+ * it to the preset's own cascade.
+ *
+ * Values are `#rrggbb` or `rgba(r, g, b, a)`. The preset's one colour
+ * function, `color-mix(in oklab, var(--primary) N%, transparent)`, is the
+ * primary at alpha N% (mixing with transparent only scales alpha), so it is
+ * written that way here.
+ */
+const STATUS_NAMES = ["success", "warning", "info", "danger"];
+export const COLOR_TOKENS = [
+    "background",
+    "foreground",
+    "card",
+    "card-foreground",
+    "popover",
+    "popover-foreground",
+    "primary",
+    "primary-foreground",
+    "secondary",
+    "secondary-foreground",
+    "muted",
+    "muted-foreground",
+    "accent",
+    "accent-foreground",
+    "destructive",
+    "border",
+    "input",
+    "ring",
+    "chart-1",
+    "chart-2",
+    "chart-3",
+    "chart-4",
+    "chart-5",
+    "sidebar",
+    "sidebar-foreground",
+    "sidebar-primary",
+    "sidebar-primary-foreground",
+    "sidebar-accent",
+    "sidebar-accent-foreground",
+    "sidebar-border",
+    "sidebar-ring",
+    "sidebar-muted-foreground",
+    "surface-0",
+    "surface-1",
+    "surface-2",
+    ...STATUS_NAMES.flatMap((name) => [name, `${name}-fg`, `${name}-bg`, `${name}-border`]),
+];
+export { ACCENT_KEYS, DEFAULT_ACCENT, GROUNDS, GROUND_KEYS };
+/** The ground `:root` paints when nothing chooses one (the preset's default). */
+export const DEFAULT_GROUND = "black";
+/**
+ * The type stacks of the preset (`--font-sans`, `--font-mono`, `--font-head`
+ * in preset.css; a test holds them equal). Each names the app's loaded font
+ * variable first, then the family, then system fallbacks.
+ */
+export const FONTS = {
+    sans: 'var(--font-plex-sans, "IBM Plex Sans"), system-ui, sans-serif',
+    mono: 'var(--font-plex-mono, "IBM Plex Mono"), ui-monospace, SFMono-Regular, Menlo, monospace',
+    head: 'var(--font-dm-sans, "DM Sans"), system-ui, sans-serif',
+};
+/** The family a stack names, for targets that take one font name (React Native). */
+export function fontFamily(stack) {
+    const name = /"([^"]+)"/.exec(stack)?.[1];
+    if (!name)
+        throw new Error(`no family in ${stack}`);
+    return name;
+}
+/** `--radius` in px, and the motion durations in ms, as numbers. */
+export function staticNumbers() {
+    const n = (value, unit) => {
+        if (!value?.endsWith(unit))
+            throw new Error(`expected ${unit}: ${value}`);
+        return Number(value.slice(0, -unit.length));
+    };
+    return {
+        radius: n(STATIC_TOKENS.radius, "px"),
+        motion: {
+            fast: n(STATIC_TOKENS["motion-fast"], "ms"),
+            base: n(STATIC_TOKENS["motion-base"], "ms"),
+            slow: n(STATIC_TOKENS["motion-slow"], "ms"),
+        },
+    };
+}
+/** Parses `#rrggbb` or `rgba(r, g, b, a)`; anything else is a token this module does not know. */
+export function parseColor(value) {
+    const hex = /^#([0-9a-f]{6})$/i.exec(value);
+    if (hex) {
+        const n = parseInt(hex[1] ?? "", 16);
+        return { r: (n >> 16) & 255, g: (n >> 8) & 255, b: n & 255, a: 1 };
+    }
+    const fn = /^rgba\((\d+), (\d+), (\d+), ([0-9.]+)\)$/.exec(value);
+    if (fn)
+        return { r: Number(fn[1]), g: Number(fn[2]), b: Number(fn[3]), a: Number(fn[4]) };
+    throw new Error(`unsupported colour ${value}`);
+}
+const rgbaString = ({ r, g, b, a }) => `rgba(${r}, ${g}, ${b}, ${a})`;
+/**
+ * A translucent token laid on its surface, for targets with no alpha
+ * (a terminal, Tk): `sidebar-*` tokens on the sidebar, the rest on the
+ * background. Opaque tokens come back as they are.
+ */
+export function flatten(palette, token) {
+    const top = parseColor(palette[token]);
+    if (top.a === 1)
+        return top;
+    const base = parseColor(palette[token.startsWith("sidebar-") ? "sidebar" : "background"]);
+    if (base.a !== 1)
+        throw new Error(`${token} sits on a translucent surface`);
+    const mix = (t, b) => Math.round(t * top.a + b * (1 - top.a));
+    return { r: mix(top.r, base.r), g: mix(top.g, base.g), b: mix(top.b, base.b), a: 1 };
+}
+const PRIMARY_TINT = /^color-mix\(in oklab, var\(--primary\) (\d+)%, transparent\)$/;
+/** A surface value: a colour as it is, or the preset's primary tint at its alpha. */
+function surface(value, primary) {
+    const tint = PRIMARY_TINT.exec(value);
+    if (tint)
+        return rgbaString({ ...parseColor(primary), a: Number(tint[1]) / 100 });
+    parseColor(value);
+    return value;
+}
+/** The concrete palette of one ground with one family accent, with no product brand. */
+export function resolvePalette(ground, accent = DEFAULT_ACCENT) {
+    const { mode } = GROUNDS[ground];
+    const s = SURFACES[ground];
+    const m = MODE_TOKENS[mode];
+    const spec = ACCENTS[accent];
+    const primary = mode === "dark" ? spec.dark : spec.light;
+    const onPrimary = mode === "dark" ? spec.onDark : spec.onLight;
+    const chart = { ...m.chart, ...spec.chart?.[mode] };
+    const status = Object.fromEntries(STATUS_NAMES.flatMap((name) => {
+        const t = m.status[name];
+        return [
+            [name, t.base],
+            [`${name}-fg`, t.fg],
+            [`${name}-bg`, t.bg],
+            [`${name}-border`, t.border],
+        ];
+    }));
+    const palette = {
+        background: s.background,
+        foreground: m.foreground,
+        card: s.card,
+        "card-foreground": m.foreground,
+        popover: s.popover,
+        "popover-foreground": m.foreground,
+        primary,
+        "primary-foreground": onPrimary,
+        secondary: s.secondary,
+        "secondary-foreground": m.foreground,
+        muted: s.muted,
+        "muted-foreground": s.mutedForeground,
+        accent: s.accent,
+        "accent-foreground": m.foreground,
+        destructive: m.destructive,
+        border: s.border,
+        input: s.input,
+        ring: primary,
+        "chart-1": primary,
+        ...chart,
+        // With no product brand, a brand sidebar falls back to the ground's card.
+        sidebar: s.sidebar === "brand" ? s.card : s.sidebar,
+        "sidebar-foreground": m.sidebarForeground,
+        "sidebar-primary": primary,
+        "sidebar-primary-foreground": onPrimary,
+        "sidebar-accent": s.sidebarAccent,
+        "sidebar-accent-foreground": m.foreground,
+        "sidebar-border": s.sidebarBorder,
+        "sidebar-ring": primary,
+        "sidebar-muted-foreground": s.mutedForeground,
+        "surface-0": s.background,
+        "surface-1": s.card,
+        "surface-2": s.popover,
+        ...status,
+    };
+    for (const token of COLOR_TOKENS)
+        palette[token] = surface(palette[token], primary);
+    return palette;
+}
+/** Every ground with every family accent. */
+export function allPalettes() {
+    return Object.fromEntries(GROUND_KEYS.map((ground) => [
+        ground,
+        Object.fromEntries(ACCENT_KEYS.map((accent) => [accent, resolvePalette(ground, accent)])),
+    ]));
+}
+/**
+ * A target's values split for compact output: per ground, the entries every
+ * accent agrees on, and per ground and accent, the entries that move with
+ * the accent.
+ */
+export function splitByAccent(values) {
+    const ground = {};
+    const accent = {};
+    for (const g of GROUND_KEYS) {
+        const each = ACCENT_KEYS.map((a) => [a, values(g, a)]);
+        const first = each[0][1];
+        const keys = Object.keys(first);
+        const moves = new Set(keys.filter((k) => each.some(([, v]) => JSON.stringify(v[k]) !== JSON.stringify(first[k]))));
+        ground[g] = Object.fromEntries(keys.filter((k) => !moves.has(k)).map((k) => [k, first[k]]));
+        accent[g] = Object.fromEntries(each.map(([a, v]) => [a, Object.fromEntries([...moves].map((k) => [k, v[k]]))]));
+    }
+    return { ground, accent };
+}

package/dist/theme/mappings/render.d.ts

@@ -0,0 +1,9 @@
+export declare function renderJupyterLabCss(): string;
+export declare function renderVsCodeCss(): string;
+export declare function renderPlainCss(): string;
+export declare function renderPython(): string;
+export declare function renderNativeJs(): string;
+export declare function renderNativeDts(): string;
+export declare function renderReadmes(): Record<string, string>;
+/** Every generated file under src/tokens/, by file name. */
+export declare function renderTokenFiles(): Record<string, string>;