jaml-ui 0.21.2 → 0.21.4

package/dist/lib/jaml/jamlSchema.js

@@ -0,0 +1,91 @@
+/**
+ * JAML Schema Bridge
+ *
+ * Derives all JAML schema constants from motely-wasm/jaml.schema.json.
+ * All JAML-aware files import from here — single swap point if the API changes.
+ */
+import jamlSchemaJson from '../../../jaml.schema.json';
+const schema = jamlSchemaJson;
+const clauseDef = schema.definitions?.clause?.properties ?? {};
+export const JAML_SCHEMA_VERSION = schema.version ?? 'unknown';
+/** The raw JSON schema object. */
+export const jamlSchema = schema;
+// ── Key groups ─────────────────────────────────────────────────────────────
+/** Root-level metadata keys (name, author, deck, etc.) */
+export const METADATA_KEYS = [
+    'id', 'name', 'description', 'author', 'dateCreated',
+    'deck', 'stake', 'seeds', 'hashtags', 'aesthetics', 'defaults',
+];
+/** Section keys that contain clause arrays. */
+export const SECTION_KEYS = ['must', 'should', 'mustNot'];
+/** Clause type keys — the primary discriminators (joker, voucher, tarot, etc.). */
+export const CLAUSE_TYPE_KEYS = (clauseDef.type?.enum ?? []);
+/** Property keys available inside a clause. */
+export const PROPERTY_KEYS = Object.keys(clauseDef);
+/** Source-configuration keys (shopItems, boosterPacks, etc.). */
+export const SOURCE_KEYS = (() => {
+    const srcProps = clauseDef.sources?.properties;
+    return srcProps ? Object.keys(srcProps) : ['shopItems', 'boosterPacks'];
+})();
+// ── Value lookups ──────────────────────────────────────────────────────────
+/**
+ * Get the valid enum values for a given JAML key.
+ * Checks top-level properties first, then falls back to clause properties.
+ */
+export function getValidValuesForKey(key) {
+    // Top-level enum (deck, stake)
+    const topProp = schema.properties?.[key];
+    if (topProp?.enum)
+        return topProp.enum;
+    if (topProp?.items?.enum)
+        return topProp.items.enum;
+    // Clause-level enum
+    const clauseProp = clauseDef[key];
+    if (clauseProp?.enum)
+        return clauseProp.enum;
+    if (clauseProp?.items?.enum)
+        return clauseProp.items.enum;
+    return null;
+}
+/**
+ * Get the available properties for a given clause type.
+ * Returns all clause property keys (the type system doesn't restrict per-type in JSON schema v7).
+ */
+export function getAvailablePropsForType(_clauseType) {
+    return PROPERTY_KEYS;
+}
+/**
+ * Check if a property is invalid for a clause type.
+ * In the v7 schema, all properties are available on all clause types.
+ */
+export function isInvalidPropForType(_prop, _clauseType) {
+    return false;
+}
+/**
+ * Check if a value is invalid for a property.
+ */
+export function isInvalidValueForProp(value, prop) {
+    const valid = getValidValuesForKey(prop);
+    if (!valid)
+        return false; // No enum constraint — anything goes
+    return !valid.includes(value);
+}
+// ── Convenience lookups ────────────────────────────────────────────────────
+export const DECK_VALUES = (getValidValuesForKey('deck') ?? []);
+export const STAKE_VALUES = (getValidValuesForKey('stake') ?? []);
+export const EDITION_VALUES = (getValidValuesForKey('edition') ?? []);
+export const SEAL_VALUES = (getValidValuesForKey('seal') ?? []);
+export const ENHANCEMENT_VALUES = (getValidValuesForKey('enhancement') ?? []);
+export const RANK_VALUES = (getValidValuesForKey('rank') ?? []);
+export const SUIT_VALUES = (getValidValuesForKey('suit') ?? []);
+export const STICKER_VALUES = (getValidValuesForKey('stickers') ?? []);
+/**
+ * All JAML keywords — sections, metadata keys, clause types, and property keys.
+ */
+export const ALL_JAML_KEYWORDS = [
+    ...SECTION_KEYS,
+    ...METADATA_KEYS,
+    ...CLAUSE_TYPE_KEYS,
+    ...PROPERTY_KEYS,
+    ...SOURCE_KEYS,
+];

package/dist/lib/parseDailyRitual.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Parser for daily_ritual.json abbreviated format
+ *
+ * Expands abbreviated fields like "wj2", "hc1" into full item objects
+ */
+export interface ParsedItem {
+    id: string;
+    name: string;
+    type: 'joker' | 'consumable' | 'voucher';
+    ante: number;
+}
+export interface ParsedSeed {
+    seed: string;
+    title: string;
+    score: number;
+    twos: number;
+    items: ParsedItem[];
+}
+/**
+ * Parse daily_ritual.json seed format
+ *
+ * Example input:
+ * {"id":"J4SPZMWW","t":"Twosday","j":"Joker","s":206,"w":16,"wj2":1,"hc2":1}
+ *
+ * Output:
+ * {
+ *   seed: "J4SPZMWW",
+ *   title: "Twosday",
+ *   score: 206,
+ *   twos: 16,
+ *   items: [
+ *     { id: 'weejoker', name: 'Wee Joker', type: 'joker', ante: 2 },
+ *     { id: 'hangingchad', name: 'Hanging Chad', type: 'joker', ante: 2 }
+ *   ]
+ * }
+ */
+export declare function parseDailyRitualSeed(raw: any): ParsedSeed;
+/**
+ * Group items by type for rendering
+ */
+export declare function groupItemsByType(items: ParsedItem[]): {
+    jokers: ParsedItem[];
+    consumables: ParsedItem[];
+    vouchers: ParsedItem[];
+};

package/dist/lib/parseDailyRitual.js

@@ -0,0 +1,69 @@
+/**
+ * Parser for daily_ritual.json abbreviated format
+ *
+ * Expands abbreviated fields like "wj2", "hc1" into full item objects
+ */
+// Mapping of abbreviations to full item data
+const ITEM_MAP = {
+    wj: { id: 'weejoker', name: 'Wee Joker', type: 'joker' },
+    hc: { id: 'hangingchad', name: 'Hanging Chad', type: 'joker' },
+    hk: { id: 'hack', name: 'Hack', type: 'joker' },
+    bp: { id: 'blueprint', name: 'Blueprint', type: 'joker' },
+    bs: { id: 'brainstorm', name: 'Brainstorm', type: 'joker' },
+    sh: { id: 'showman', name: 'Showman', type: 'joker' },
+    cp: { id: 'copy', name: 'Copy', type: 'consumable' }, // Placeholder
+    // Add more as needed
+};
+/**
+ * Parse daily_ritual.json seed format
+ *
+ * Example input:
+ * {"id":"J4SPZMWW","t":"Twosday","j":"Joker","s":206,"w":16,"wj2":1,"hc2":1}
+ *
+ * Output:
+ * {
+ *   seed: "J4SPZMWW",
+ *   title: "Twosday",
+ *   score: 206,
+ *   twos: 16,
+ *   items: [
+ *     { id: 'weejoker', name: 'Wee Joker', type: 'joker', ante: 2 },
+ *     { id: 'hangingchad', name: 'Hanging Chad', type: 'joker', ante: 2 }
+ *   ]
+ * }
+ */
+export function parseDailyRitualSeed(raw) {
+    const items = [];
+    // Parse each field looking for pattern: letters + number (e.g., "wj2", "hc1")
+    Object.keys(raw).forEach(key => {
+        const match = key.match(/^([a-z]+)(\d+)$/);
+        if (match) {
+            const [, code, ante] = match;
+            const itemData = ITEM_MAP[code];
+            if (itemData) {
+                const count = raw[key]; // Could be used for duplicates
+                items.push({
+                    ...itemData,
+                    ante: Number(ante)
+                });
+            }
+        }
+    });
+    return {
+        seed: raw.id || '',
+        title: raw.t || '',
+        score: raw.s || 0,
+        twos: raw.w || 0,
+        items
+    };
+}
+/**
+ * Group items by type for rendering
+ */
+export function groupItemsByType(items) {
+    return {
+        jokers: items.filter(i => i.type === 'joker'),
+        consumables: items.filter(i => i.type === 'consumable'),
+        vouchers: items.filter(i => i.type === 'voucher')
+    };
+}

package/dist/lib/tts/getRevealPos.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Advance past trailing punctuation and whitespace so reveal snaps to word boundaries.
+ * Used by both JammySpeechBox (home announcement) and ChatInterface (streaming chat).
+ */
+export declare function getRevealPos(text: string, highlightPos: number): number;

package/dist/lib/tts/getRevealPos.js

@@ -0,0 +1,16 @@
+/**
+ * Advance past trailing punctuation and whitespace so reveal snaps to word boundaries.
+ * Used by both JammySpeechBox (home announcement) and ChatInterface (streaming chat).
+ */
+export function getRevealPos(text, highlightPos) {
+    if (highlightPos <= 0)
+        return 0;
+    if (highlightPos >= text.length)
+        return text.length;
+    let i = highlightPos;
+    while (i < text.length && /[)\]}'"'\u2018\u2019.,!?;:]/.test(text[i]))
+        i++;
+    while (i < text.length && /\s/.test(text[i]))
+        i++;
+    return i;
+}

package/dist/lib/tts/splitTtsDisplay.d.ts

@@ -0,0 +1,19 @@
+/** Strip markdown markers only — do not collapse whitespace (TTS highlight indices are raw offsets). */
+export declare function stripMarkdownForTtsDisplay(text: string): string;
+export type TtsDisplaySplit = {
+    prefix: string;
+    spoken: string;
+    pending: string;
+    suffix: string;
+    useWindowedView: boolean;
+};
+/**
+ * Split plain text into spoken vs pending regions for TTS word sync.
+ * When `stripMarkdown` is false, indices must refer to `text` as-is (matches streaming TTS offsets).
+ */
+export declare function splitTtsDisplay(text: string, highlightPos: number | null | undefined, activeSentenceRange: {
+    start: number;
+    end: number;
+} | null | undefined, options?: {
+    stripMarkdown?: boolean;
+}): TtsDisplaySplit | null;

package/dist/lib/tts/splitTtsDisplay.js

@@ -0,0 +1,35 @@
+import { getRevealPos } from "./getRevealPos";
+/** Strip markdown markers only — do not collapse whitespace (TTS highlight indices are raw offsets). */
+export function stripMarkdownForTtsDisplay(text) {
+    return text
+        .replace(/```[\s\S]*?```/g, "")
+        .replace(/\*\*/g, "")
+        .trim();
+}
+/**
+ * Split plain text into spoken vs pending regions for TTS word sync.
+ * When `stripMarkdown` is false, indices must refer to `text` as-is (matches streaming TTS offsets).
+ */
+export function splitTtsDisplay(text, highlightPos, activeSentenceRange, options) {
+    const body = options?.stripMarkdown ? stripMarkdownForTtsDisplay(text) : text;
+    if (!body)
+        return null;
+    const ttsDisabled = highlightPos === null || highlightPos === undefined;
+    if (ttsDisabled)
+        return null;
+    const hasTtsHighlight = typeof highlightPos === "number" && highlightPos >= 0;
+    const hasActiveSentence = Boolean(activeSentenceRange && activeSentenceRange.start >= 0 && activeSentenceRange.end > activeSentenceRange.start);
+    const sentenceStart = hasActiveSentence ? Math.min(activeSentenceRange.start, body.length) : 0;
+    const sentenceEnd = hasActiveSentence ? Math.min(activeSentenceRange.end, body.length) : body.length;
+    const revealPos = hasTtsHighlight
+        ? Math.min(Math.max(getRevealPos(body, highlightPos), sentenceStart), sentenceEnd)
+        : 0;
+    const useWindowedView = hasTtsHighlight && hasActiveSentence;
+    const displayStart = useWindowedView ? sentenceStart : 0;
+    const displayEnd = useWindowedView ? sentenceEnd : body.length;
+    const prefix = useWindowedView ? "" : body.slice(0, sentenceStart);
+    const spoken = body.slice(displayStart, Math.min(revealPos, displayEnd));
+    const pending = body.slice(Math.min(revealPos, displayEnd), displayEnd);
+    const suffix = useWindowedView ? "" : body.slice(sentenceEnd);
+    return { prefix, spoken, pending, suffix, useWindowedView };
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,121 @@
+export type DeckType = 'red' | 'blue' | 'yellow' | 'green' | 'black' | 'magic' | 'nebula' | 'ghost' | 'abandoned' | 'checkered' | 'zodiac' | 'painted' | 'anaglyph' | 'plasma' | 'erratic';
+export type StakeType = 'white' | 'red' | 'green' | 'black' | 'blue' | 'purple' | 'orange' | 'gold';
+/**
+ * Configuration for a Daily Ritual challenge
+ * Matches the dailyritual.schema.json structure
+ */
+export interface RitualConfig {
+    filterId: string;
+    searchId: string;
+    deck: DeckType;
+    stake: StakeType;
+    seeds: string;
+    name: string;
+    author: string;
+    description?: string;
+    tutorial?: string;
+    epoch?: string;
+    icon?: string;
+    color?: string;
+}
+/**
+ * Seed data record from the seeds file.
+ * All scoring fields are dynamic — driven by the JAML filter's label columns.
+ */
+export interface SeedData {
+    seed: string;
+    score: number;
+    stake?: StakeType;
+    startingDeck?: string[];
+    relevantEvents?: RelevantEvent[];
+    [key: string]: string | number | boolean | string[] | RelevantEvent[] | undefined;
+}
+export interface ParsedCard {
+    rank: string;
+    suit: string;
+    enhancement: string | null;
+    seal: string | null;
+    edition: string | null;
+}
+/**
+ * The type of a game event/item
+ */
+export type RelevantEventType = 'joker' | 'tarot' | 'spectral' | 'planet' | 'voucher';
+/**
+ * The source/location where the event occurs in game
+ */
+export type EventSource = 'shop' | 'arcana_pack' | 'spectral_pack' | 'celestial_pack' | 'buffoon_pack' | 'standard_pack' | 'tag' | 'boss_blind' | 'voucher';
+/**
+ * A "relevant" event as defined by the JAML filter's Should rules.
+ * Represents anything the ritual cares about tracking (jokers, consumables, etc.)
+ */
+export interface RelevantEvent {
+    /** The ante number (1, 2, 3, ...) when this event occurs */
+    ante: number;
+    /** Where this event occurs (shop, pack, tag, etc.) */
+    source: EventSource;
+    /** The category of item */
+    type: RelevantEventType;
+    /** The item's identifier (e.g., "weejoker", "temperance", "blueprint") */
+    id: string;
+    /** Optional edition modifier (e.g., "negative", "polychrome", "foil", "holographic") */
+    edition?: string;
+    /** Optional enhancement (for standard cards: "bonus", "mult", "wild", etc.) */
+    enhancement?: string;
+    /** Optional seal (for standard cards: "gold", "red", "blue", "purple") */
+    seal?: string;
+    /** Count of this item (defaults to 1 if not specified) */
+    count?: number;
+    /** Optional display name override */
+    displayName?: string;
+}
+/**
+ * Complete seed data as exported in a JAMZ file.
+ * This is the "rich" data format containing everything needed to render the UI.
+ */
+export interface JamzSeedData {
+    /** The 8-character Balatro seed string */
+    seed: string;
+    /** Calculated "goodness" score from the JAML filter */
+    score: number;
+    /** Count of Rank 2s in the starting deck (for Erratic deck display) */
+    twos?: number;
+    /** The exact 52 cards in starting deck. Format: {rank}_{suit} e.g., ["2_C", "10_H", "A_S"] */
+    startingDeck?: string[];
+    /** All relevant events matching the JAML filter's Should rules */
+    relevantEvents?: RelevantEvent[];
+    /** Legacy: individual JAML column values (for backward compatibility) */
+    [key: string]: string | number | boolean | string[] | RelevantEvent[] | undefined;
+}
+/**
+ * Header metadata in a JAMZ file
+ */
+export interface JamzHeader {
+    /** JAMZ format version (e.g., "1") */
+    version: string;
+    /** Hash of the source JAML filter for verification */
+    jamlHash: string;
+    /** Total number of seeds in this file */
+    seedCount: number;
+    /** ISO 8601 timestamp when this file was generated */
+    generatedAt: string;
+    /** Ritual metadata */
+    ritual: {
+        id: string;
+        name: string;
+        author: string;
+        description?: string;
+        tutorial?: string;
+        deck: DeckType;
+        stake: StakeType;
+        icon?: string;
+        color?: string;
+    };
+}
+/**
+ * Complete JAMZ file structure (after decompression and JSON parsing)
+ */
+export interface JamzFile {
+    header: JamzHeader;
+    seeds: JamzSeedData[];
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/ui/JimboIconButton.d.ts

@@ -0,0 +1,10 @@
+import type React from "react";
+export interface JimboIconButtonProps {
+    "aria-label"?: string;
+    children: React.ReactNode;
+    disabled?: boolean;
+    onClick?: () => void;
+    size?: "sm" | "md";
+    title?: string;
+}
+export declare function JimboIconButton({ onClick, title, "aria-label": ariaLabel, disabled, size, children, }: JimboIconButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/JimboIconButton.js

@@ -0,0 +1,28 @@
+// PORTABLE — intended for jaml-ui/src/ui/jimboIconButton.tsx
+// On paste, replace `from 'jaml-ui'` with `from './tokens.js'`.
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { JimboColorOption } from "./tokens.js";
+import { useState } from "react";
+const C = JimboColorOption;
+export function JimboIconButton({ onClick, title, "aria-label": ariaLabel, disabled = false, size = "md", children, }) {
+    const [hover, setHover] = useState(false);
+    const side = size === "sm" ? 26 : 30;
+    return (_jsx("button", { "aria-label": ariaLabel ?? title, disabled: disabled, onClick: () => !disabled && onClick?.(), onMouseEnter: () => setHover(true), onMouseLeave: () => setHover(false), style: {
+            width: side,
+            height: side,
+            display: "inline-flex",
+            alignItems: "center",
+            justifyContent: "center",
+            background: hover && !disabled ? C.DARK_GREY : C.DARKEST,
+            color: C.WHITE,
+            border: `1px solid ${C.PANEL_EDGE}`,
+            borderRadius: 4,
+            cursor: disabled ? "not-allowed" : "pointer",
+            opacity: disabled ? 0.55 : 1,
+            padding: 0,
+            fontSize: 14,
+            lineHeight: 1,
+            transition: "background 80ms ease",
+        }, title: title, type: "button", children: children }));
+}

package/dist/ui/JimboInputModal.d.ts

@@ -0,0 +1,13 @@
+export interface JimboInputModalProps {
+    cancelLabel?: string;
+    confirmLabel?: string;
+    initialValue?: string;
+    message?: string;
+    onCancel: () => void;
+    onConfirm: (value: string) => void;
+    open: boolean;
+    placeholder?: string;
+    title: string;
+    validate?: (value: string) => string | null;
+}
+export declare function JimboInputModal({ open, title, message, placeholder, initialValue, confirmLabel, cancelLabel, validate, onConfirm, onCancel, }: JimboInputModalProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/JimboInputModal.js

@@ -0,0 +1,60 @@
+// PORTABLE — intended for jaml-ui/src/ui/jimboInputModal.tsx
+// On paste, replace `from 'jaml-ui'` with `from './panel.js'`/`./tokens.js` as appropriate.
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { JimboButton, JimboModal } from "./panel.js";
+import { JimboColorOption } from "./tokens.js";
+import { JimboText } from "./jimboText.js";
+import { useEffect, useRef, useState } from "react";
+const C = JimboColorOption;
+export function JimboInputModal({ open, title, message, placeholder, initialValue = "", confirmLabel = "Confirm", cancelLabel = "Cancel", validate, onConfirm, onCancel, }) {
+    const [value, setValue] = useState(initialValue);
+    const [error, setError] = useState(null);
+    const inputRef = useRef(null);
+    useEffect(() => {
+        if (open) {
+            setValue(initialValue);
+            setError(null);
+            const t = setTimeout(() => inputRef.current?.focus(), 30);
+            return () => clearTimeout(t);
+        }
+    }, [open, initialValue]);
+    function submit() {
+        const err = validate?.(value) ?? null;
+        if (err) {
+            setError(err);
+            return;
+        }
+        onConfirm(value);
+    }
+    return (_jsxs(JimboModal, { onClose: onCancel, open: open, title: title, children: [message && (_jsx(JimboText, { size: "sm", style: { display: "block", marginBottom: 8 }, tone: "grey", children: message })), _jsx("input", { "aria-invalid": error ? "true" : "false", onChange: (e) => {
+                    setValue(e.target.value);
+                    if (error) {
+                        setError(null);
+                    }
+                }, onKeyDown: (e) => {
+                    if (e.key === "Enter") {
+                        submit();
+                    }
+                    if (e.key === "Escape") {
+                        onCancel();
+                    }
+                }, placeholder: placeholder, ref: inputRef, style: {
+                    width: "100%",
+                    padding: "8px 10px",
+                    background: C.DARKEST,
+                    color: C.WHITE,
+                    border: `1px solid ${error ? C.RED : C.PANEL_EDGE}`,
+                    borderRadius: 4,
+                    fontSize: 13,
+                    fontFamily: "m6x11plus, monospace",
+                    letterSpacing: 1,
+                    outline: "none",
+                    boxSizing: "border-box",
+                }, type: "text", value: value }), error && (_jsx(JimboText, { size: "sm", style: { display: "block", marginTop: 6 }, tone: "red", children: error })), _jsxs("div", { style: {
+                    display: "flex",
+                    justifyContent: "flex-end",
+                    gap: 8,
+                    marginTop: 14,
+                }, children: [_jsx(JimboButton, { onClick: onCancel, size: "sm", tone: "red", children: cancelLabel }), _jsx(JimboButton, { onClick: submit, size: "sm", tone: "blue", children: confirmLabel })] })] }));
+}

package/dist/ui/JimboSelect.d.ts

@@ -0,0 +1,18 @@
+import type React from "react";
+export interface JimboSelectOption {
+    disabled?: boolean;
+    label?: string;
+    value: string;
+}
+export interface JimboSelectProps {
+    "aria-label"?: string;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    onChange: (value: string) => void;
+    options: JimboSelectOption[] | string[];
+    placeholder?: string;
+    size?: "sm" | "md";
+    style?: React.CSSProperties;
+    value: string;
+}
+export declare function JimboSelect({ value, options, onChange, placeholder, disabled, fullWidth, size, style, "aria-label": ariaLabel, }: JimboSelectProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/JimboSelect.js

@@ -0,0 +1,43 @@
+// PORTABLE — intended for jaml-ui/src/ui/jimboSelect.tsx
+// On paste, replace `from 'jaml-ui'` with `from './tokens.js'`.
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { JimboColorOption } from "./tokens.js";
+const C = JimboColorOption;
+export function JimboSelect({ value, options, onChange, placeholder, disabled = false, fullWidth = true, size = "md", style, "aria-label": ariaLabel, }) {
+    let normalized;
+    if (options.length === 0) {
+        normalized = [];
+    }
+    else if (typeof options[0] === "string") {
+        normalized = options.map((v) => ({ value: v }));
+    }
+    else {
+        normalized = options;
+    }
+    const pad = size === "sm" ? "4px 8px" : "6px 10px";
+    const fontSize = size === "sm" ? 11 : 12;
+    return (_jsxs("select", { "aria-label": ariaLabel, disabled: disabled, onChange: (e) => onChange(e.target.value), style: {
+            width: fullWidth ? "100%" : undefined,
+            padding: pad,
+            background: C.DARKEST,
+            color: C.WHITE,
+            border: `1px solid ${C.PANEL_EDGE}`,
+            borderRadius: 4,
+            fontSize,
+            fontFamily: "m6x11plus, monospace",
+            cursor: disabled ? "not-allowed" : "pointer",
+            opacity: disabled ? 0.55 : 1,
+            appearance: "none",
+            backgroundImage: "linear-gradient(45deg, transparent 50%, " +
+                C.GOLD_TEXT +
+                " 50%), linear-gradient(135deg, " +
+                C.GOLD_TEXT +
+                " 50%, transparent 50%)",
+            backgroundPosition: "calc(100% - 12px) 50%, calc(100% - 7px) 50%",
+            backgroundSize: "5px 5px, 5px 5px",
+            backgroundRepeat: "no-repeat",
+            paddingRight: 22,
+            ...style,
+        }, value: value, children: [placeholder !== undefined && (_jsx("option", { disabled: true, value: "", children: placeholder })), normalized.map((opt) => (_jsx("option", { disabled: opt.disabled, value: opt.value, children: opt.label ?? opt.value }, opt.value)))] }));
+}

package/dist/ui/PanelSplitter.d.ts

@@ -0,0 +1,7 @@
+export interface PanelSplitterProps {
+    "aria-label"?: string;
+    onDrag: (delta: number) => void;
+    onKeyAdjust?: (delta: number) => void;
+    orientation?: "vertical" | "horizontal";
+}
+export declare function PanelSplitter({ orientation, onDrag, onKeyAdjust, "aria-label": ariaLabel, }: PanelSplitterProps): import("react/jsx-runtime").JSX.Element;