@uipath/apollo-wind 2.60.1 → 2.62.0

package/dist/components/forms/value-modes.d.ts

@@ -0,0 +1,236 @@
+import type { LucideIcon } from 'lucide-react';
+import type * as React from 'react';
+import { type ValueModeOption } from '../ui/field-addons/built-in-value-modes';
+import type { ValueModeStrings } from '../ui/field-addons/value-mode-strings';
+import type { InputGroupLayout, InputGroupProps } from '../ui/input-group';
+import type { VariablePickerItem } from '../ui/variable-picker';
+import type { FieldControlLabelTarget } from './field-control';
+import type { CustomFieldComponentProps, CustomValueType, FieldMetadata, FieldType, FormPlugin, FormSchema, ValueModeId, ValueModesConfig } from './form-schema';
+/** A stored value split into its mode and the value written in that mode. */
+export interface DecodedValue {
+    mode: ValueModeId;
+    /** For `literal`, the value in its field type's own shape, which that type's validation runs on. */
+    value: unknown;
+    /** Set by a codec that knows; otherwise `isEmpty` decides. */
+    empty?: boolean;
+}
+export interface CodecContext {
+    field: FieldMetadata;
+    /** The field's type, whose control edits `literal` values. */
+    fieldType: FieldType;
+    valueType?: CustomValueType;
+    /** The value's type as a mode describes it: `valueModes.expectedType`, else the field type's. */
+    expectedType?: string;
+    config: ValueModesConfig;
+}
+/**
+ * A switch's outcome, `value` being the value in the new mode, which the form encodes. `ok` writes
+ * it straight away; `lossy` asks first, with the codec's own wording when it gives one.
+ */
+export type ConvertResult = {
+    kind: 'ok';
+    value: unknown;
+} | {
+    kind: 'lossy';
+    value: unknown;
+    title?: string;
+    description?: string;
+};
+/**
+ * How a field's stored value carries its mode. Validating a value in a mode belongs to the mode:
+ * see `ValueModeDefinition.validate`.
+ */
+export interface ValueModeCodec {
+    /**
+     * The active mode and the value in it. Only the active mode's: a shape that keeps other modes'
+     * data alongside gets it back as `encode`'s `previous`.
+     */
+    decode(stored: unknown, ctx: CodecContext): DecodedValue;
+    /**
+     * The stored value for `inner` in `mode`. `previous` is the value stored until now, so a shape
+     * holding more than the active mode's value (another mode's draft, a flag) can carry it over.
+     * Never `undefined`: react-hook-form reads it as unset and shows the field's default instead, so
+     * an empty value is `null` or a shape of the codec's own. `inner` is `null` or `undefined` when
+     * the value is cleared.
+     */
+    encode(mode: ValueModeId, inner: unknown, ctx: CodecContext, previous?: unknown): unknown;
+    /**
+     * The value in `to` for a switch from `from`. Called for an empty value too, with `from.empty`
+     * set, so a switch can seed a value; an empty value never asks, whatever `kind` says. Without
+     * it, an empty value switches to nothing and a non-empty one clears, lossily.
+     */
+    convert?(from: DecodedValue, to: ValueModeId, ctx: CodecContext): ConvertResult;
+    /** Drives `required` and Clear. Defaults to the form's usual notion of empty. */
+    isEmpty?(decoded: DecodedValue, ctx: CodecContext): boolean;
+}
+/** How the default codec stores a value, in every mode. A cleared value has no `value`. */
+export interface ValueModeEnvelope {
+    $mode: ValueModeId;
+    value?: unknown;
+}
+export declare function isValueModeEnvelope(value: unknown): value is ValueModeEnvelope;
+/**
+ * The default codec. Every mode is stored as `{ $mode, value }`; a cleared value keeps its
+ * envelope without `value`, so its mode survives. A raw value reads as `literal`, so data written
+ * before the field had value modes still loads; its first write wraps it. `$mode` rather than
+ * `mode`, so an object value that has a `mode` of its own is not misread.
+ */
+export declare const envelopeCodec: ValueModeCodec;
+export declare function isDecodedEmpty(codec: ValueModeCodec, decoded: DecodedValue, ctx: CodecContext): boolean;
+/**
+ * Switches `from` to `to`, returning the value in `to`: an empty value never asks, and a codec
+ * without `convert` clears a non-empty one, lossily.
+ */
+export declare function convertValue(codec: ValueModeCodec, from: DecodedValue, to: ValueModeId, ctx: CodecContext): ConvertResult;
+export declare function codecContext(field: FieldMetadata, config: ValueModesConfig): CodecContext;
+export interface ValueModeControlHandle {
+    focus(): void;
+    /**
+     * Inserts at the caret. Needed by a control registered as `insertable` that has no text input
+     * of its own for the form to insert into, such as a code editor.
+     */
+    insertText?(text: string): void;
+}
+/**
+ * Props of a registered value-mode control. A superset of `CustomFieldComponentProps`, so an
+ * existing custom component can be registered as a control unchanged. In the field anatomy both
+ * get the value in the active mode (a custom field's fixed value), never the stored shape.
+ */
+export interface ValueModeControlProps extends CustomFieldComponentProps {
+    mode: ValueModeId;
+    /** The value in `mode`, not the stored shape. */
+    value: unknown;
+    onChange: (inner: unknown) => void;
+    /** Writes a value in another mode without asking, as pasting an expression does. */
+    onModeValueChange: (mode: ValueModeId, inner: unknown) => void;
+    /** Switches mode the way the menu does, asking first if the value would be lost. */
+    requestModeSwitch: (mode: ValueModeId) => void;
+    controlRef?: React.Ref<ValueModeControlHandle>;
+    inputRef?: React.Ref<unknown>;
+    /** The id the field's label points at, when the registration's `labelTarget` is `control`. */
+    id: string;
+    /** The label's id, for `aria-labelledby` on a control no label can point at. */
+    labelId: string;
+    invalid: boolean;
+    placeholder?: string;
+    /** The form's variables for this field, resolved when called; never call it during render. */
+    variables: () => VariablePickerItem[];
+    /** The form's value-mode strings. */
+    strings: ValueModeStrings;
+    /** Spread on the element that takes focus, so the group's focus ring and error wiring find it. */
+    controlProps: {
+        'data-slot': 'input-group-control';
+        'aria-invalid'?: true;
+        'aria-describedby'?: string;
+        'aria-errormessage'?: string;
+    };
+}
+export type InputGroupVariant = NonNullable<InputGroupProps['variant']>;
+/** A component with its geometry inside the field anatomy. */
+export interface FieldControlRegistration<P> {
+    component: React.ComponentType<P>;
+    /** Defaults to `row`. */
+    layout?: InputGroupLayout;
+    /** Defaults to `default`. */
+    variant?: InputGroupVariant;
+    /**
+     * How the label reaches the control: `control` points it at the element with `id`;
+     * `labelledby` leaves the control to name itself with `aria-labelledby={labelId}`, as a code
+     * editor or a radio group must. Defaults to `control`.
+     */
+    labelTarget?: FieldControlLabelTarget;
+    /**
+     * Whether Insert variable writes at the caret. The control's `controlRef` handle does it, or,
+     * without one, the text input carrying `id`; with neither the reference is appended.
+     */
+    insertable?: boolean;
+}
+export declare function isFieldControlRegistration<P>(entry: React.ComponentType<P> | FieldControlRegistration<P>): entry is FieldControlRegistration<P>;
+/** A value control with its geometry, for value modes. */
+export type ValueModeControlRegistration = FieldControlRegistration<ValueModeControlProps>;
+/**
+ * A mode apollo-wind does not ship, or changes to a built-in one. For a built-in id every member is
+ * optional and merges over the built-in, whose localized title and description stay unless given.
+ * A mode of the host's own needs `icon` and `title`.
+ */
+export interface ValueModeDefinition {
+    icon?: LucideIcon;
+    title?: string | ((ctx: {
+        field: FieldMetadata;
+    }) => string);
+    description?: string;
+    /** The glyph ahead of the value in this mode. */
+    indicator?: React.ReactNode;
+    /** The control for this mode on every field. A field's own `valueModes.controls[mode]` wins. */
+    control?: ValueModeControlRegistration;
+    /**
+     * Validates a non-empty value in this mode, such as an expression's syntax. Never called for
+     * `literal`, which its field type validates.
+     */
+    validate?(value: unknown, ctx: CodecContext): string | undefined;
+}
+/**
+ * Form-wide value-mode behavior.
+ *
+ * A field's control for its active mode is the first of:
+ * 1. the field's `valueModes.controls[mode]`, a name in `controlRegistry`;
+ * 2. for `literal`, `literalControls[fieldType]`, since a fixed value is edited per field type;
+ * 3. `definitions[mode].control`;
+ * 4. the built-in: the field type's own control for `literal`, a plain Input for `expression`,
+ *    `VariableValueControl` for `variable` and `PromptValueControl` for `prompt`;
+ * 5. for a host mode with none of these, a plain Input, with a warning.
+ *
+ * Only a field schema refers to controls by name, since it has to stay JSON; the plugin's own
+ * settings hold the registration itself.
+ *
+ * @example
+ * const code = { component: CodeControl, layout: 'fill', insertable: true };
+ * valueModes: {
+ *   // Every expression edits in the code control…
+ *   definitions: { expression: { control: code } },
+ *   // …every fixed textarea value in a rich-text one…
+ *   literalControls: { textarea: { component: RichTextControl, layout: 'grow', insertable: true } },
+ *   // …and a field can ask for the code control by name: `controls: { literal: 'code' }`.
+ *   controlRegistry: { code },
+ * }
+ */
+export interface ValueModesPluginConfig {
+    /** Codecs by name; `default` replaces the envelope codec form-wide. */
+    codecs?: Record<string, ValueModeCodec>;
+    /** Mode definitions by mode id: a host mode, or changes to a built-in one. */
+    definitions?: Partial<Record<ValueModeId, ValueModeDefinition>>;
+    /**
+     * Controls a field schema can name in `valueModes.controls`. A name is any string of the host's
+     * choosing; it is not a mode id or a field type.
+     */
+    controlRegistry?: Record<string, ValueModeControlRegistration>;
+    /**
+     * The `literal` control per field type, for those with fixed values the host edits in its own
+     * control rather than the default one for that field type.
+     */
+    literalControls?: Partial<Record<FieldType, ValueModeControlRegistration>>;
+}
+/** Every plugin's `valueModes`, merged with later plugins winning. */
+export interface ValueModeRegistry {
+    codecs: Record<string, ValueModeCodec>;
+    definitions: Partial<Record<ValueModeId, ValueModeDefinition>>;
+    controlRegistry: Record<string, ValueModeControlRegistration>;
+    literalControls: Partial<Record<FieldType, ValueModeControlRegistration>>;
+}
+/** The registry of a form whose plugins configure no value modes. Frozen, as it is shared. */
+export declare const DEFAULT_VALUE_MODE_REGISTRY: Readonly<ValueModeRegistry>;
+export declare function buildValueModeRegistry(plugins: readonly FormPlugin[]): ValueModeRegistry;
+export declare function resolveCodec(codecs: Record<string, ValueModeCodec>, config: ValueModesConfig): ValueModeCodec;
+/** The menu entries for a field's modes, in its order. Ids with no definition are left out. */
+export declare function resolveModeOptions(field: FieldMetadata, config: ValueModesConfig, registry: ValueModeRegistry, strings?: Partial<ValueModeStrings>): ValueModeOption<string>[];
+/** Whether a stored value is empty, decoding it first for a field with value modes. */
+export declare function isEmptyModeValue(stored: unknown, field: FieldMetadata, codecs?: Record<string, ValueModeCodec>): boolean;
+export { VALUE_MODE_OPAQUE } from './opaque-value';
+/**
+ * Form values as rules, conditions and data sources read them. A field with value modes reads as
+ * its `literal` value; a value in another mode as `VALUE_MODE_OPAQUE`, and an empty one as
+ * `undefined`. Fields without value modes read as stored.
+ */
+export declare function literalValues(values: Record<string, unknown>, schema: FormSchema, codecs?: Record<string, ValueModeCodec>): Record<string, unknown>;
+/** One field's value as `literalValues` reads it: `stored` as it is for a field without modes. */
+export declare function literalValueOf(name: string, stored: unknown, schema: FormSchema, codecs?: Record<string, ValueModeCodec>): unknown;

package/dist/components/forms/value-modes.js

@@ -0,0 +1,180 @@
+import { builtInValueModes, isBuiltInValueMode } from "../ui/field-addons/built-in-value-modes.js";
+import { get } from "../../lib/index.js";
+import { VALUE_MODE_OPAQUE } from "./opaque-value.js";
+import { isEmptyFieldValue } from "./validation-converter.js";
+function isValueModeEnvelope(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value) && 'string' == typeof value.$mode;
+}
+const envelopeCodec = {
+    decode (stored) {
+        if (isValueModeEnvelope(stored)) return {
+            mode: stored.$mode,
+            value: stored.value
+        };
+        return {
+            mode: 'literal',
+            value: stored
+        };
+    },
+    encode (mode, inner) {
+        return isCleared(inner) ? {
+            $mode: mode
+        } : {
+            $mode: mode,
+            value: inner
+        };
+    },
+    isEmpty (decoded) {
+        return isEmptyFieldValue(decoded.value) || Number.isNaN(decoded.value);
+    }
+};
+function isCleared(value) {
+    return null == value || '' === value || Number.isNaN(value) || Array.isArray(value) && 0 === value.length;
+}
+function isDecodedEmpty(codec, decoded, ctx) {
+    return decoded.empty ?? codec.isEmpty?.(decoded, ctx) ?? isEmptyFieldValue(decoded.value);
+}
+function convertValue(codec, from, to, ctx) {
+    const empty = isDecodedEmpty(codec, from, ctx);
+    const result = codec.convert?.({
+        ...from,
+        empty
+    }, to, ctx);
+    if (empty) return {
+        kind: 'ok',
+        value: result?.value
+    };
+    return result ?? {
+        kind: 'lossy',
+        value: void 0
+    };
+}
+function codecContext(field, config) {
+    return {
+        field,
+        fieldType: field.type,
+        valueType: 'custom' === field.type ? field.valueType : void 0,
+        expectedType: expectedType(field, config),
+        config
+    };
+}
+function isFieldControlRegistration(entry) {
+    return 'object' == typeof entry && null !== entry && 'component' in entry;
+}
+const DEFAULT_VALUE_MODE_REGISTRY = Object.freeze({
+    codecs: Object.freeze({}),
+    definitions: Object.freeze({}),
+    controlRegistry: Object.freeze({}),
+    literalControls: Object.freeze({})
+});
+function buildValueModeRegistry(plugins) {
+    const registry = {
+        codecs: {},
+        definitions: {},
+        controlRegistry: {},
+        literalControls: {}
+    };
+    for (const { valueModes } of plugins)if (valueModes) {
+        Object.assign(registry.codecs, valueModes.codecs);
+        for (const [id, definition] of Object.entries(valueModes.definitions ?? {}))registry.definitions[id] = {
+            ...registry.definitions[id],
+            ...definition
+        };
+        Object.assign(registry.controlRegistry, valueModes.controlRegistry);
+        Object.assign(registry.literalControls, valueModes.literalControls);
+    }
+    return registry;
+}
+function resolveCodec(codecs, config) {
+    return codecs[config.codec ?? 'default'] ?? envelopeCodec;
+}
+function expectedType(field, config) {
+    if (config?.expectedType) return config.expectedType;
+    if ('number' === field.type) return 'number';
+    if ('switch' === field.type || 'checkbox' === field.type || 'boolean' === field.type) return 'boolean';
+    if ('custom' === field.type) return field.valueType;
+}
+function resolveModeOptions(field, config, registry, strings = {}) {
+    const builtIns = builtInValueModes(strings, {
+        expectedType: expectedType(field, config)
+    });
+    const options = [];
+    for (const id of config.modes){
+        const definition = registry.definitions[id];
+        const label = config.labels?.[id];
+        const base = isBuiltInValueMode(id) ? builtIns[id] : {};
+        const title = 'function' == typeof definition?.title ? definition.title({
+            field
+        }) : definition?.title;
+        const option = {
+            ...base,
+            id,
+            ...void 0 !== title && {
+                title
+            },
+            ...definition?.description !== void 0 && {
+                description: definition.description
+            },
+            ...definition?.icon && {
+                icon: definition.icon
+            }
+        };
+        if (option.title && option.icon) options.push({
+            ...option,
+            title: label?.title ?? option.title,
+            icon: option.icon,
+            description: label?.description ?? option.description
+        });
+    }
+    return options;
+}
+function isEmptyModeValue(stored, field, codecs = {}) {
+    if (!field.valueModes) return isEmptyFieldValue(stored);
+    const codec = resolveCodec(codecs, field.valueModes);
+    const ctx = codecContext(field, field.valueModes);
+    return isDecodedEmpty(codec, codec.decode(stored, ctx), ctx);
+}
+function literalValues(values, schema, codecs = {}) {
+    let result = values;
+    for (const field of modeFields(schema)){
+        const stored = get(values, field.name);
+        const read = readLiteral(stored, field, codecs);
+        if (read !== stored) result = withPath(result, field.name.split('.'), read);
+    }
+    return result;
+}
+function literalValueOf(name, stored, schema, codecs = {}) {
+    const field = modeFields(schema).find((candidate)=>candidate.name === name);
+    return field ? readLiteral(stored, field, codecs) : stored;
+}
+function readLiteral(stored, field, codecs) {
+    const config = field.valueModes;
+    const codec = resolveCodec(codecs, config);
+    const ctx = codecContext(field, config);
+    const decoded = codec.decode(stored, ctx);
+    if (isDecodedEmpty(codec, decoded, ctx)) return;
+    return 'literal' === decoded.mode ? decoded.value : VALUE_MODE_OPAQUE;
+}
+const modeFieldsCache = new WeakMap();
+function modeFields(schema) {
+    let fields = modeFieldsCache.get(schema);
+    if (!fields) {
+        const sections = schema.steps?.flatMap((step)=>step.sections) ?? schema.sections ?? [];
+        fields = sections.flatMap((section)=>section.fields).filter((field)=>field.valueModes);
+        modeFieldsCache.set(schema, fields);
+    }
+    return fields;
+}
+function withPath(target, path, value) {
+    const [key, ...rest] = path;
+    if (void 0 === key) return target;
+    const container = 'object' == typeof target && null !== target ? target : {};
+    const copy = Array.isArray(container) ? [
+        ...container
+    ] : {
+        ...container
+    };
+    copy[key] = rest.length ? withPath(copy[key], rest, value) : value;
+    return copy;
+}
+export { DEFAULT_VALUE_MODE_REGISTRY, VALUE_MODE_OPAQUE, buildValueModeRegistry, codecContext, convertValue, envelopeCodec, isDecodedEmpty, isEmptyModeValue, isFieldControlRegistration, isValueModeEnvelope, literalValueOf, literalValues, resolveCodec, resolveModeOptions };

package/dist/components/ui/avatar.d.ts

@@ -2,7 +2,7 @@ import * as AvatarPrimitive from '@radix-ui/react-avatar';
 import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const avatarVariants: (props?: ({
-    size?: "sm" | "lg" | "default" | null | undefined;
+    size?: "default" | "lg" | "sm" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface AvatarProps extends React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>, VariantProps<typeof avatarVariants> {
 }

package/dist/components/ui/badge.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const badgeVariants: (props?: ({
-    variant?: "default" | "secondary" | "destructive" | "outline" | "error" | "warning" | "info" | "success" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "error" | "warning" | "info" | "success" | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface BadgeProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
 }

package/dist/components/ui/boolean-radio-group.cjs

@@ -0,0 +1,114 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BooleanRadioGroup: ()=>BooleanRadioGroup,
+    DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS: ()=>DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const external_react_namespaceObject = require("react");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const external_input_group_context_cjs_namespaceObject = require("./input-group-context.cjs");
+const external_label_cjs_namespaceObject = require("./label.cjs");
+const external_radio_group_cjs_namespaceObject = require("./radio-group.cjs");
+const DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS = {
+    trueLabel: 'True',
+    falseLabel: 'False'
+};
+const OPTIONS = [
+    {
+        value: 'true',
+        key: 'trueLabel'
+    },
+    {
+        value: 'false',
+        key: 'falseLabel'
+    }
+];
+const BooleanRadioGroup = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ value, onValueChange, strings, disabled: disabledProp, className, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedBy, 'aria-errormessage': ariaErrorMessage, ...props }, ref)=>{
+    const text = {
+        ...DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS,
+        ...strings
+    };
+    const groupId = external_react_namespaceObject.useId();
+    const group = (0, external_input_group_context_cjs_namespaceObject.useInputGroup)();
+    const { inGroup } = group;
+    const disabled = disabledProp || group.disabled;
+    const aria = (0, external_input_group_context_cjs_namespaceObject.controlValidation)(group, {
+        'aria-invalid': ariaInvalid,
+        'aria-describedby': ariaDescribedBy,
+        'aria-errormessage': ariaErrorMessage
+    });
+    const checked = 'boolean' == typeof value ? String(value) : '';
+    const handleValueChange = external_react_namespaceObject.useCallback((next)=>onValueChange('true' === next), [
+        onValueChange
+    ]);
+    const clearIfChecked = external_react_namespaceObject.useCallback((event)=>{
+        if (event.currentTarget.value === checked) onValueChange(null);
+    }, [
+        checked,
+        onValueChange
+    ]);
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_radio_group_cjs_namespaceObject.RadioGroup, {
+        ref: ref,
+        value: checked,
+        onValueChange: handleValueChange,
+        disabled: disabled,
+        className: (0, index_cjs_namespaceObject.cn)('flex flex-1 items-center gap-4', className),
+        ...props,
+        ...aria,
+        children: OPTIONS.map((option)=>{
+            const itemId = `${groupId}-${option.value}`;
+            return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
+                className: "flex items-center gap-1.5",
+                children: [
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_radio_group_cjs_namespaceObject.RadioGroupItem, {
+                        id: itemId,
+                        value: option.value,
+                        ...inGroup && {
+                            'data-slot': 'input-group-control'
+                        },
+                        onClick: clearIfChecked
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_label_cjs_namespaceObject.Label, {
+                        htmlFor: itemId,
+                        className: (0, index_cjs_namespaceObject.cn)('font-normal', disabled ? 'cursor-not-allowed' : 'cursor-pointer'),
+                        children: text[option.key]
+                    })
+                ]
+            }, option.value);
+        })
+    });
+});
+BooleanRadioGroup.displayName = 'BooleanRadioGroup';
+exports.BooleanRadioGroup = __webpack_exports__.BooleanRadioGroup;
+exports.DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS = __webpack_exports__.DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BooleanRadioGroup",
+    "DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/components/ui/boolean-radio-group.d.ts

@@ -0,0 +1,24 @@
+import * as React from 'react';
+import { RadioGroup } from './radio-group';
+export interface BooleanRadioGroupStrings {
+    trueLabel: string;
+    falseLabel: string;
+}
+export declare const DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS: BooleanRadioGroupStrings;
+export interface BooleanRadioGroupProps extends Omit<React.ComponentPropsWithoutRef<typeof RadioGroup>, 'value' | 'defaultValue' | 'onValueChange' | 'children'> {
+    /**
+     * `null` is the unset state, with neither radio checked; `undefined` reads the same. Unset is
+     * reported as `null`, the cleared value form libraries such as react-hook-form expect.
+     */
+    value: boolean | null | undefined;
+    onValueChange: (value: boolean | null) => void;
+    /** Overrides for any subset of the English strings. */
+    strings?: Partial<BooleanRadioGroupStrings>;
+}
+/**
+ * True / False radios with a third, unset state, for a boolean that may have no value: a switch or
+ * checkbox can only show two. Clicking the checked radio clears the value. Inside an `InputGroup`
+ * both radios are the group's control, so its focus ring answers to either.
+ */
+declare const BooleanRadioGroup: React.ForwardRefExoticComponent<BooleanRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+export { BooleanRadioGroup };

package/dist/components/ui/boolean-radio-group.js

@@ -0,0 +1,77 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { forwardRef, useCallback, useId } from "react";
+import { cn } from "../../lib/index.js";
+import { controlValidation, useInputGroup } from "./input-group-context.js";
+import { Label } from "./label.js";
+import { RadioGroup, RadioGroupItem } from "./radio-group.js";
+const DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS = {
+    trueLabel: 'True',
+    falseLabel: 'False'
+};
+const OPTIONS = [
+    {
+        value: 'true',
+        key: 'trueLabel'
+    },
+    {
+        value: 'false',
+        key: 'falseLabel'
+    }
+];
+const BooleanRadioGroup = /*#__PURE__*/ forwardRef(({ value, onValueChange, strings, disabled: disabledProp, className, 'aria-invalid': ariaInvalid, 'aria-describedby': ariaDescribedBy, 'aria-errormessage': ariaErrorMessage, ...props }, ref)=>{
+    const text = {
+        ...DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS,
+        ...strings
+    };
+    const groupId = useId();
+    const group = useInputGroup();
+    const { inGroup } = group;
+    const disabled = disabledProp || group.disabled;
+    const aria = controlValidation(group, {
+        'aria-invalid': ariaInvalid,
+        'aria-describedby': ariaDescribedBy,
+        'aria-errormessage': ariaErrorMessage
+    });
+    const checked = 'boolean' == typeof value ? String(value) : '';
+    const handleValueChange = useCallback((next)=>onValueChange('true' === next), [
+        onValueChange
+    ]);
+    const clearIfChecked = useCallback((event)=>{
+        if (event.currentTarget.value === checked) onValueChange(null);
+    }, [
+        checked,
+        onValueChange
+    ]);
+    return /*#__PURE__*/ jsx(RadioGroup, {
+        ref: ref,
+        value: checked,
+        onValueChange: handleValueChange,
+        disabled: disabled,
+        className: cn('flex flex-1 items-center gap-4', className),
+        ...props,
+        ...aria,
+        children: OPTIONS.map((option)=>{
+            const itemId = `${groupId}-${option.value}`;
+            return /*#__PURE__*/ jsxs("div", {
+                className: "flex items-center gap-1.5",
+                children: [
+                    /*#__PURE__*/ jsx(RadioGroupItem, {
+                        id: itemId,
+                        value: option.value,
+                        ...inGroup && {
+                            'data-slot': 'input-group-control'
+                        },
+                        onClick: clearIfChecked
+                    }),
+                    /*#__PURE__*/ jsx(Label, {
+                        htmlFor: itemId,
+                        className: cn('font-normal', disabled ? 'cursor-not-allowed' : 'cursor-pointer'),
+                        children: text[option.key]
+                    })
+                ]
+            }, option.value);
+        })
+    });
+});
+BooleanRadioGroup.displayName = 'BooleanRadioGroup';
+export { BooleanRadioGroup, DEFAULT_BOOLEAN_RADIO_GROUP_STRINGS };

package/dist/components/ui/button.d.ts

@@ -1,8 +1,8 @@
 import { type VariantProps } from 'class-variance-authority';
 import * as React from 'react';
 declare const buttonVariants: (props?: ({
-    variant?: "text" | "default" | "secondary" | "destructive" | "outline" | "ghost" | "link" | null | undefined;
-    size?: "sm" | "lg" | "default" | "xs" | "2xs" | "3xs" | "4xs" | "icon" | null | undefined;
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | "text" | null | undefined;
+    size?: "default" | "lg" | "sm" | "xs" | "2xs" | "3xs" | "4xs" | "icon" | null | undefined;
     icon?: boolean | null | undefined;
 } & import("class-variance-authority/types").ClassProp) | undefined) => string;
 export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {