@uipath/apollo-wind 2.49.0 → 2.51.0

package/dist/components/forms/string-list-field.js

@@ -0,0 +1,117 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { Plus, Trash2 } from "lucide-react";
+import { useCallback, useState } from "react";
+import { Button } from "../ui/button.js";
+import { FormField, FormFieldDescription, FormFieldError, FormFieldLabel } from "../ui/form-field.js";
+import { Textarea } from "../ui/textarea.js";
+function formatTemplate(template, values) {
+    return template.replace(/\{\{(\w+)\}\}/g, (match, token)=>token in values ? String(values[token]) : match);
+}
+function StringListField({ field, value, onChange, onBlur, error, disabled = false, required = false, inputRef }) {
+    const items = value ?? [];
+    const maxItems = field.maxItems ?? 1 / 0;
+    const canAdd = !disabled && items.length < maxItems;
+    const addItemLabel = field.addItemLabel ?? 'Add';
+    const removeItemAriaLabel = field.removeItemAriaLabel ?? 'Remove {{label}} {{position}}';
+    const [rowIds, setRowIds] = useState(()=>items.map(()=>crypto.randomUUID()));
+    const [prevLength, setPrevLength] = useState(items.length);
+    if (prevLength !== items.length) {
+        setPrevLength(items.length);
+        setRowIds((prev)=>prev.length < items.length ? [
+                ...prev,
+                ...Array.from({
+                    length: items.length - prev.length
+                }, ()=>crypto.randomUUID())
+            ] : prev.slice(0, items.length));
+    }
+    const addItem = useCallback(()=>{
+        setRowIds((prev)=>[
+                ...prev,
+                crypto.randomUUID()
+            ]);
+        onChange([
+            ...items,
+            ''
+        ]);
+    }, [
+        items,
+        onChange
+    ]);
+    const removeItem = useCallback((index)=>{
+        setRowIds((prev)=>prev.filter((_, i)=>i !== index));
+        onChange(items.filter((_, i)=>i !== index));
+    }, [
+        items,
+        onChange
+    ]);
+    const updateItem = useCallback((index, next)=>{
+        onChange(items.map((item, i)=>i === index ? next : item));
+    }, [
+        items,
+        onChange
+    ]);
+    return /*#__PURE__*/ jsxs(FormField, {
+        "data-slot": "string-list-field",
+        children: [
+            /*#__PURE__*/ jsx(FormFieldLabel, {
+                required: required,
+                tooltip: field.tooltip,
+                tooltipAriaLabel: field.tooltipAriaLabel,
+                children: field.label
+            }),
+            /*#__PURE__*/ jsx("div", {
+                className: "grid gap-1.5",
+                children: items.map((item, index)=>/*#__PURE__*/ jsxs("div", {
+                        className: "flex items-start gap-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Textarea, {
+                                ref: 0 === index ? inputRef : void 0,
+                                value: item,
+                                onChange: (e)=>updateItem(index, e.target.value),
+                                onBlur: onBlur,
+                                minRows: field.minRows ?? 2,
+                                maxLength: field.maxLength,
+                                disabled: disabled,
+                                "aria-label": `${field.label} ${index + 1}`,
+                                "aria-invalid": error ? true : void 0,
+                                className: "flex-1"
+                            }),
+                            /*#__PURE__*/ jsx(Button, {
+                                type: "button",
+                                variant: "ghost",
+                                size: "sm",
+                                icon: true,
+                                disabled: disabled,
+                                onClick: ()=>removeItem(index),
+                                "aria-label": formatTemplate(removeItemAriaLabel, {
+                                    label: field.label,
+                                    position: index + 1
+                                }),
+                                className: "shrink-0 text-muted-foreground",
+                                children: /*#__PURE__*/ jsx(Trash2, {})
+                            })
+                        ]
+                    }, rowIds[index] ?? index))
+            }),
+            canAdd && /*#__PURE__*/ jsx("div", {
+                children: /*#__PURE__*/ jsxs(Button, {
+                    type: "button",
+                    variant: "text",
+                    size: "2xs",
+                    onClick: addItem,
+                    children: [
+                        /*#__PURE__*/ jsx(Plus, {}),
+                        addItemLabel
+                    ]
+                })
+            }),
+            /*#__PURE__*/ jsx(FormFieldDescription, {
+                children: field.description
+            }),
+            /*#__PURE__*/ jsx(FormFieldError, {
+                children: error
+            })
+        ]
+    });
+}
+export { StringListField, formatTemplate };

package/dist/components/forms/validation-converter.cjs

@@ -24,24 +24,45 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    mergeValidationConfigs: ()=>mergeValidationConfigs,
     buildZodSchemaFromFields: ()=>buildZodSchemaFromFields,
-    validationConfigToZod: ()=>validationConfigToZod,
-    mergeValidationConfigs: ()=>mergeValidationConfigs
+    isEmptyFieldValue: ()=>isEmptyFieldValue,
+    validationConfigToZod: ()=>validationConfigToZod
 });
 const external_zod_namespaceObject = require("zod");
-function validationConfigToZod(config, fieldType) {
-    let schema = getBaseSchemaForType(fieldType);
+const external_rules_engine_cjs_namespaceObject = require("./rules-engine.cjs");
+function validationConfigToZod(config, fieldType, customValueType) {
+    let schema = getBaseSchemaForType(fieldType, customValueType);
     if (!config) return schema.optional();
-    schema = applyStringConstraints(schema, config, fieldType);
-    schema = applyNumberConstraints(schema, config, fieldType);
-    schema = applyArrayConstraints(schema, config, fieldType);
+    schema = applyStringConstraints(schema, config, fieldType, customValueType);
+    schema = applyNumberConstraints(schema, config, fieldType, customValueType);
+    schema = applyArrayConstraints(schema, config, fieldType, customValueType);
     if (config.required) {
-        if (isStringType(fieldType) && !config.minLength) schema = schema.min(1, config.messages?.required || 'This field is required');
-        return schema;
+        const requiredMessage = config.messages?.required || 'This field is required';
+        if (isStringType(fieldType, customValueType)) schema = schema.refine((value)=>!isEmptyFieldValue(value), {
+            message: requiredMessage
+        });
+        if (isArrayType(fieldType, customValueType) && (null == config.minItems || config.minItems < 1)) schema = schema.min(1, requiredMessage);
+        return applyCustomExpression(schema, config);
     }
-    return schema.optional();
+    return applyCustomExpression(schema, config).optional();
+}
+function applyCustomExpression(schema, config) {
+    if (!config.custom) return schema;
+    const expression = config.custom;
+    const message = config.messages?.custom || 'This value is not valid';
+    return schema.superRefine((value, ctx)=>{
+        const result = external_rules_engine_cjs_namespaceObject.RulesEngine.tryEvaluateExpression(expression, {
+            value
+        });
+        if (!result.ok) return;
+        if (!result.value) ctx.addIssue({
+            code: 'custom',
+            message
+        });
+    });
 }
-function getBaseSchemaForType(fieldType) {
+function getBaseSchemaForType(fieldType, customValueType) {
     switch(fieldType){
         case 'text':
         case 'textarea':
@@ -58,6 +79,7 @@ function getBaseSchemaForType(fieldType) {
         case 'radio':
             return external_zod_namespaceObject.z.string();
         case 'multiselect':
+        case 'string-list':
             return external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string());
         case 'date':
             return external_zod_namespaceObject.z.coerce.date();
@@ -66,12 +88,30 @@ function getBaseSchemaForType(fieldType) {
         case 'file':
             return external_zod_namespaceObject.z.any();
         case 'custom':
-            return external_zod_namespaceObject.z.any();
+            switch(customValueType){
+                case 'string':
+                    return external_zod_namespaceObject.z.string();
+                case 'number':
+                    return external_zod_namespaceObject.z.number();
+                case 'boolean':
+                    return external_zod_namespaceObject.z.boolean();
+                case 'string-array':
+                    return external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string());
+                default:
+                    return external_zod_namespaceObject.z.any();
+            }
         default:
             return external_zod_namespaceObject.z.string();
     }
 }
-function isStringType(fieldType) {
+function isEmptyFieldValue(value) {
+    if (null == value) return true;
+    if ('string' == typeof value) return '' === value.trim();
+    if (Array.isArray(value)) return 0 === value.length;
+    return false;
+}
+function isStringType(fieldType, customValueType) {
+    if ('custom' === fieldType) return 'string' === customValueType;
     return [
         'text',
         'textarea',
@@ -80,19 +120,22 @@ function isStringType(fieldType) {
         'radio'
     ].includes(fieldType);
 }
-function isNumberType(fieldType) {
+function isNumberType(fieldType, customValueType) {
+    if ('custom' === fieldType) return 'number' === customValueType;
     return [
         'number',
         'slider'
     ].includes(fieldType);
 }
-function isArrayType(fieldType) {
+function isArrayType(fieldType, customValueType) {
+    if ('custom' === fieldType) return 'string-array' === customValueType;
     return [
-        'multiselect'
+        'multiselect',
+        'string-list'
     ].includes(fieldType);
 }
-function applyStringConstraints(schema, config, fieldType) {
-    if (!isStringType(fieldType)) return schema;
+function applyStringConstraints(schema, config, fieldType, customValueType) {
+    if (!isStringType(fieldType, customValueType)) return schema;
     let stringSchema = schema;
     if (null != config.minLength) stringSchema = stringSchema.min(config.minLength, config.messages?.minLength || `Must be at least ${config.minLength} characters`);
     if (null != config.maxLength) stringSchema = stringSchema.max(config.maxLength, config.messages?.maxLength || `Must be at most ${config.maxLength} characters`);
@@ -106,8 +149,8 @@ function applyStringConstraints(schema, config, fieldType) {
     if (config.url) stringSchema = stringSchema.url(config.messages?.url || 'Invalid URL');
     return stringSchema;
 }
-function applyNumberConstraints(schema, config, fieldType) {
-    if (!isNumberType(fieldType)) return schema;
+function applyNumberConstraints(schema, config, fieldType, customValueType) {
+    if (!isNumberType(fieldType, customValueType)) return schema;
     let numberSchema = schema;
     if (config.integer) numberSchema = numberSchema.int(config.messages?.integer || 'Must be a whole number');
     if (null != config.min) numberSchema = numberSchema.min(config.min, config.messages?.min || `Must be at least ${config.min}`);
@@ -116,8 +159,8 @@ function applyNumberConstraints(schema, config, fieldType) {
     if (config.negative) numberSchema = numberSchema.negative(config.messages?.negative || 'Must be a negative number');
     return numberSchema;
 }
-function applyArrayConstraints(schema, config, fieldType) {
-    if (!isArrayType(fieldType)) return schema;
+function applyArrayConstraints(schema, config, fieldType, customValueType) {
+    if (!isArrayType(fieldType, customValueType)) return schema;
     let arraySchema = schema;
     if (null != config.minItems) arraySchema = arraySchema.min(config.minItems, config.messages?.minItems || `Select at least ${config.minItems} item(s)`);
     if (null != config.maxItems) arraySchema = arraySchema.max(config.maxItems, config.messages?.maxItems || `Select at most ${config.maxItems} item(s)`);
@@ -125,7 +168,7 @@ function applyArrayConstraints(schema, config, fieldType) {
 }
 function buildZodSchemaFromFields(fields) {
     const shape = {};
-    for (const field of fields)shape[field.name] = validationConfigToZod(field.validation, field.type);
+    for (const field of fields)shape[field.name] = validationConfigToZod(field.validation, field.type, field.valueType);
     return external_zod_namespaceObject.z.object(shape);
 }
 function mergeValidationConfigs(base, override) {
@@ -142,10 +185,12 @@ function mergeValidationConfigs(base, override) {
     };
 }
 exports.buildZodSchemaFromFields = __webpack_exports__.buildZodSchemaFromFields;
+exports.isEmptyFieldValue = __webpack_exports__.isEmptyFieldValue;
 exports.mergeValidationConfigs = __webpack_exports__.mergeValidationConfigs;
 exports.validationConfigToZod = __webpack_exports__.validationConfigToZod;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildZodSchemaFromFields",
+    "isEmptyFieldValue",
     "mergeValidationConfigs",
     "validationConfigToZod"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/components/forms/validation-converter.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import type { ValidationConfig, FieldType } from './form-schema';
+import type { CustomValueType, FieldType, ValidationConfig } from './form-schema';
+export type { CustomValueType };
 /**
  * Validation Converter
  *
@@ -20,7 +21,21 @@ import type { ValidationConfig, FieldType } from './form-schema';
  * );
  * // Returns: z.string().min(2).email()
  */
-export declare function validationConfigToZod(config: ValidationConfig | undefined, fieldType: FieldType): z.ZodTypeAny;
+export declare function validationConfigToZod(config: ValidationConfig | undefined, fieldType: FieldType, 
+/**
+ * Declared shape of a `type: 'custom'` field's value. Custom fields otherwise validate as
+ * `z.any()`, where `required` and the array constraints are no-ops.
+ */
+customValueType?: CustomValueType): z.ZodTypeAny;
+/**
+ * Check if field type uses string schema
+ */
+/**
+ * The one definition of "empty" for a required field. Exported so the resolver and the
+ * conditional-required `superRefine` in metadata-form agree — they used to disagree, with
+ * the narrower resolver path missing whitespace-only strings.
+ */
+export declare function isEmptyFieldValue(value: unknown): boolean;
 /**
  * Build a complete Zod object schema from field validations
  *
@@ -31,6 +46,12 @@ export declare function buildZodSchemaFromFields(fields: Array<{
     name: string;
     type: FieldType;
     validation?: ValidationConfig;
+    /**
+     * Declared shape of a `type: 'custom'` field. Accepted here as well as by
+     * `validationConfigToZod`, otherwise a schema built through this helper validates every
+     * typed custom field as `z.any()` and its `required` / `minItems` quietly do nothing.
+     */
+    valueType?: CustomValueType;
 }>): z.ZodObject<Record<string, z.ZodTypeAny>>;
 /**
  * Merge multiple ValidationConfigs (for rule-based validation changes)

package/dist/components/forms/validation-converter.js

@@ -1,17 +1,37 @@
 import { z } from "zod";
-function validationConfigToZod(config, fieldType) {
-    let schema = getBaseSchemaForType(fieldType);
+import { RulesEngine } from "./rules-engine.js";
+function validationConfigToZod(config, fieldType, customValueType) {
+    let schema = getBaseSchemaForType(fieldType, customValueType);
     if (!config) return schema.optional();
-    schema = applyStringConstraints(schema, config, fieldType);
-    schema = applyNumberConstraints(schema, config, fieldType);
-    schema = applyArrayConstraints(schema, config, fieldType);
+    schema = applyStringConstraints(schema, config, fieldType, customValueType);
+    schema = applyNumberConstraints(schema, config, fieldType, customValueType);
+    schema = applyArrayConstraints(schema, config, fieldType, customValueType);
     if (config.required) {
-        if (isStringType(fieldType) && !config.minLength) schema = schema.min(1, config.messages?.required || 'This field is required');
-        return schema;
+        const requiredMessage = config.messages?.required || 'This field is required';
+        if (isStringType(fieldType, customValueType)) schema = schema.refine((value)=>!isEmptyFieldValue(value), {
+            message: requiredMessage
+        });
+        if (isArrayType(fieldType, customValueType) && (null == config.minItems || config.minItems < 1)) schema = schema.min(1, requiredMessage);
+        return applyCustomExpression(schema, config);
     }
-    return schema.optional();
+    return applyCustomExpression(schema, config).optional();
 }
-function getBaseSchemaForType(fieldType) {
+function applyCustomExpression(schema, config) {
+    if (!config.custom) return schema;
+    const expression = config.custom;
+    const message = config.messages?.custom || 'This value is not valid';
+    return schema.superRefine((value, ctx)=>{
+        const result = RulesEngine.tryEvaluateExpression(expression, {
+            value
+        });
+        if (!result.ok) return;
+        if (!result.value) ctx.addIssue({
+            code: 'custom',
+            message
+        });
+    });
+}
+function getBaseSchemaForType(fieldType, customValueType) {
     switch(fieldType){
         case 'text':
         case 'textarea':
@@ -28,6 +48,7 @@ function getBaseSchemaForType(fieldType) {
         case 'radio':
             return z.string();
         case 'multiselect':
+        case 'string-list':
             return z.array(z.string());
         case 'date':
             return z.coerce.date();
@@ -36,12 +57,30 @@ function getBaseSchemaForType(fieldType) {
         case 'file':
             return z.any();
         case 'custom':
-            return z.any();
+            switch(customValueType){
+                case 'string':
+                    return z.string();
+                case 'number':
+                    return z.number();
+                case 'boolean':
+                    return z.boolean();
+                case 'string-array':
+                    return z.array(z.string());
+                default:
+                    return z.any();
+            }
         default:
             return z.string();
     }
 }
-function isStringType(fieldType) {
+function isEmptyFieldValue(value) {
+    if (null == value) return true;
+    if ('string' == typeof value) return '' === value.trim();
+    if (Array.isArray(value)) return 0 === value.length;
+    return false;
+}
+function isStringType(fieldType, customValueType) {
+    if ('custom' === fieldType) return 'string' === customValueType;
     return [
         'text',
         'textarea',
@@ -50,19 +89,22 @@ function isStringType(fieldType) {
         'radio'
     ].includes(fieldType);
 }
-function isNumberType(fieldType) {
+function isNumberType(fieldType, customValueType) {
+    if ('custom' === fieldType) return 'number' === customValueType;
     return [
         'number',
         'slider'
     ].includes(fieldType);
 }
-function isArrayType(fieldType) {
+function isArrayType(fieldType, customValueType) {
+    if ('custom' === fieldType) return 'string-array' === customValueType;
     return [
-        'multiselect'
+        'multiselect',
+        'string-list'
     ].includes(fieldType);
 }
-function applyStringConstraints(schema, config, fieldType) {
-    if (!isStringType(fieldType)) return schema;
+function applyStringConstraints(schema, config, fieldType, customValueType) {
+    if (!isStringType(fieldType, customValueType)) return schema;
     let stringSchema = schema;
     if (null != config.minLength) stringSchema = stringSchema.min(config.minLength, config.messages?.minLength || `Must be at least ${config.minLength} characters`);
     if (null != config.maxLength) stringSchema = stringSchema.max(config.maxLength, config.messages?.maxLength || `Must be at most ${config.maxLength} characters`);
@@ -76,8 +118,8 @@ function applyStringConstraints(schema, config, fieldType) {
     if (config.url) stringSchema = stringSchema.url(config.messages?.url || 'Invalid URL');
     return stringSchema;
 }
-function applyNumberConstraints(schema, config, fieldType) {
-    if (!isNumberType(fieldType)) return schema;
+function applyNumberConstraints(schema, config, fieldType, customValueType) {
+    if (!isNumberType(fieldType, customValueType)) return schema;
     let numberSchema = schema;
     if (config.integer) numberSchema = numberSchema.int(config.messages?.integer || 'Must be a whole number');
     if (null != config.min) numberSchema = numberSchema.min(config.min, config.messages?.min || `Must be at least ${config.min}`);
@@ -86,8 +128,8 @@ function applyNumberConstraints(schema, config, fieldType) {
     if (config.negative) numberSchema = numberSchema.negative(config.messages?.negative || 'Must be a negative number');
     return numberSchema;
 }
-function applyArrayConstraints(schema, config, fieldType) {
-    if (!isArrayType(fieldType)) return schema;
+function applyArrayConstraints(schema, config, fieldType, customValueType) {
+    if (!isArrayType(fieldType, customValueType)) return schema;
     let arraySchema = schema;
     if (null != config.minItems) arraySchema = arraySchema.min(config.minItems, config.messages?.minItems || `Select at least ${config.minItems} item(s)`);
     if (null != config.maxItems) arraySchema = arraySchema.max(config.maxItems, config.messages?.maxItems || `Select at most ${config.maxItems} item(s)`);
@@ -95,7 +137,7 @@ function applyArrayConstraints(schema, config, fieldType) {
 }
 function buildZodSchemaFromFields(fields) {
     const shape = {};
-    for (const field of fields)shape[field.name] = validationConfigToZod(field.validation, field.type);
+    for (const field of fields)shape[field.name] = validationConfigToZod(field.validation, field.type, field.valueType);
     return z.object(shape);
 }
 function mergeValidationConfigs(base, override) {
@@ -111,4 +153,4 @@ function mergeValidationConfigs(base, override) {
         }
     };
 }
-export { buildZodSchemaFromFields, mergeValidationConfigs, validationConfigToZod };
+export { buildZodSchemaFromFields, isEmptyFieldValue, mergeValidationConfigs, validationConfigToZod };

package/dist/components/ui/datetime-picker.cjs

@@ -36,7 +36,7 @@ const external_input_cjs_namespaceObject = require("./input.cjs");
 const external_label_cjs_namespaceObject = require("./label.cjs");
 const external_popover_cjs_namespaceObject = require("./popover.cjs");
 const index_cjs_namespaceObject = require("../../lib/index.cjs");
-const datetime_picker_DateTimePicker = /*#__PURE__*/ external_react_namespaceObject.forwardRef(function({ value, onValueChange, disabled, placeholder = 'Pick a date and time', className, use12Hour = false }, ref) {
+const datetime_picker_DateTimePicker = /*#__PURE__*/ external_react_namespaceObject.forwardRef(function({ value, onValueChange, disabled, placeholder = 'Pick a date and time', className, use12Hour = false, 'aria-labelledby': ariaLabelledBy, 'aria-invalid': ariaInvalid }, ref) {
     const [open, setOpen] = external_react_namespaceObject.useState(false);
     const [selectedDate, setSelectedDate] = external_react_namespaceObject.useState(value);
     const [timeValue, setTimeValue] = external_react_namespaceObject.useState(value ? (0, external_date_fns_namespaceObject.format)(value, use12Hour ? 'hh:mm a' : 'HH:mm') : '');
@@ -76,6 +76,8 @@ const datetime_picker_DateTimePicker = /*#__PURE__*/ external_react_namespaceObj
                 asChild: true,
                 children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_button_cjs_namespaceObject.Button, {
                     ref: ref,
+                    "aria-labelledby": ariaLabelledBy,
+                    "aria-invalid": ariaInvalid,
                     variant: "outline",
                     className: (0, index_cjs_namespaceObject.cn)('w-full justify-start text-left font-normal [&>svg]:text-foreground-muted hover:[&>svg]:text-accent-foreground', 'future:h-10 future:rounded-xl future:border-0 future:bg-surface-overlay future:px-4 future:gap-4 future:text-foreground future:hover:bg-surface-hover future:focus-visible:ring-offset-2 future:focus-visible:ring-offset-background', className),
                     disabled: disabled,

package/dist/components/ui/datetime-picker.d.ts

@@ -6,5 +6,9 @@ export interface DateTimePickerProps {
     placeholder?: string;
     className?: string;
     use12Hour?: boolean;
+    /** Id of the element naming this control, forwarded to the trigger button. */
+    'aria-labelledby'?: string;
+    /** Marks the trigger invalid, so the error is exposed on the control itself. */
+    'aria-invalid'?: boolean;
 }
 export declare const DateTimePicker: React.ForwardRefExoticComponent<DateTimePickerProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/ui/datetime-picker.js

@@ -8,7 +8,7 @@ import { Input } from "./input.js";
 import { Label } from "./label.js";
 import { Popover, PopoverContent, PopoverTrigger } from "./popover.js";
 import { cn } from "../../lib/index.js";
-const datetime_picker_DateTimePicker = /*#__PURE__*/ forwardRef(function({ value, onValueChange, disabled, placeholder = 'Pick a date and time', className, use12Hour = false }, ref) {
+const datetime_picker_DateTimePicker = /*#__PURE__*/ forwardRef(function({ value, onValueChange, disabled, placeholder = 'Pick a date and time', className, use12Hour = false, 'aria-labelledby': ariaLabelledBy, 'aria-invalid': ariaInvalid }, ref) {
     const [open, setOpen] = useState(false);
     const [selectedDate, setSelectedDate] = useState(value);
     const [timeValue, setTimeValue] = useState(value ? format(value, use12Hour ? 'hh:mm a' : 'HH:mm') : '');
@@ -48,6 +48,8 @@ const datetime_picker_DateTimePicker = /*#__PURE__*/ forwardRef(function({ value
                 asChild: true,
                 children: /*#__PURE__*/ jsxs(Button, {
                     ref: ref,
+                    "aria-labelledby": ariaLabelledBy,
+                    "aria-invalid": ariaInvalid,
                     variant: "outline",
                     className: cn('w-full justify-start text-left font-normal [&>svg]:text-foreground-muted hover:[&>svg]:text-accent-foreground', 'future:h-10 future:rounded-xl future:border-0 future:bg-surface-overlay future:px-4 future:gap-4 future:text-foreground future:hover:bg-surface-hover future:focus-visible:ring-offset-2 future:focus-visible:ring-offset-background', className),
                     disabled: disabled,

package/dist/components/ui/form-field.cjs

@@ -31,6 +31,7 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
+const external_info_tooltip_cjs_namespaceObject = require("./info-tooltip.cjs");
 const external_label_cjs_namespaceObject = require("./label.cjs");
 const index_cjs_namespaceObject = require("../../lib/index.cjs");
 const FormField = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ children, className, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
@@ -41,15 +42,29 @@ const FormField = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ chi
         children: children
     }));
 FormField.displayName = 'FormField';
-const FormFieldLabel = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ children, required = false, ...props }, ref)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_label_cjs_namespaceObject.Label, {
+const FormFieldLabel = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ children, required = false, tooltip, tooltipAriaLabel, className, ...props }, ref)=>{
+    const label = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(external_label_cjs_namespaceObject.Label, {
         ref: ref,
         "data-slot": "form-field-label",
+        className: className,
         ...props,
         children: [
             children,
             required && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_label_cjs_namespaceObject.RequiredIndicator, {})
         ]
-    }));
+    });
+    if (null == tooltip || false === tooltip) return label;
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("span", {
+        className: "inline-flex items-center",
+        children: [
+            label,
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_info_tooltip_cjs_namespaceObject.InfoTooltip, {
+                content: tooltip,
+                "aria-label": tooltipAriaLabel ?? 'More information'
+            })
+        ]
+    });
+});
 FormFieldLabel.displayName = 'FormFieldLabel';
 const FormFieldDescription = /*#__PURE__*/ external_react_namespaceObject.forwardRef(({ children, className, ...props }, ref)=>{
     if (!children) return null;

package/dist/components/ui/form-field.d.ts

@@ -19,6 +19,13 @@ declare const FormField: React.ForwardRefExoticComponent<Omit<React.DetailedHTML
 export interface FormFieldLabelProps extends React.ComponentPropsWithoutRef<typeof Label> {
     /** Appends the required indicator after the label text. */
     required?: boolean;
+    /**
+     * Appends an info-tooltip trigger after the label text and the required indicator.
+     * Requires an ancestor `TooltipProvider` (Radix throws without one).
+     */
+    tooltip?: React.ReactNode;
+    /** Accessible name of the tooltip trigger. Defaults to 'More information'. */
+    tooltipAriaLabel?: string;
 }
 /** Names the field. Pair with a control via `htmlFor`. */
 declare const FormFieldLabel: React.ForwardRefExoticComponent<FormFieldLabelProps & React.RefAttributes<HTMLLabelElement>>;

package/dist/components/ui/form-field.js

@@ -1,5 +1,6 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { forwardRef } from "react";
+import { InfoTooltip } from "./info-tooltip.js";
 import { Label, RequiredIndicator } from "./label.js";
 import { cn } from "../../lib/index.js";
 const FormField = /*#__PURE__*/ forwardRef(({ children, className, ...props }, ref)=>/*#__PURE__*/ jsx("div", {
@@ -10,15 +11,29 @@ const FormField = /*#__PURE__*/ forwardRef(({ children, className, ...props }, r
         children: children
     }));
 FormField.displayName = 'FormField';
-const FormFieldLabel = /*#__PURE__*/ forwardRef(({ children, required = false, ...props }, ref)=>/*#__PURE__*/ jsxs(Label, {
+const FormFieldLabel = /*#__PURE__*/ forwardRef(({ children, required = false, tooltip, tooltipAriaLabel, className, ...props }, ref)=>{
+    const label = /*#__PURE__*/ jsxs(Label, {
         ref: ref,
         "data-slot": "form-field-label",
+        className: className,
         ...props,
         children: [
             children,
             required && /*#__PURE__*/ jsx(RequiredIndicator, {})
         ]
-    }));
+    });
+    if (null == tooltip || false === tooltip) return label;
+    return /*#__PURE__*/ jsxs("span", {
+        className: "inline-flex items-center",
+        children: [
+            label,
+            /*#__PURE__*/ jsx(InfoTooltip, {
+                content: tooltip,
+                "aria-label": tooltipAriaLabel ?? 'More information'
+            })
+        ]
+    });
+});
 FormFieldLabel.displayName = 'FormFieldLabel';
 const FormFieldDescription = /*#__PURE__*/ forwardRef(({ children, className, ...props }, ref)=>{
     if (!children) return null;