@tempots/beatui 0.82.1 → 0.83.0

package/dist/types/components/form/input/mask-input.d.ts

@@ -1,6 +1,13 @@
 import { Value, Renderable } from '@tempots/dom';
 import { Merge } from '@tempots/std';
 import { InputOptions } from './input-options';
+/**
+ * Represents a single token in a parsed mask definition.
+ *
+ * - `'literal'` tokens represent fixed characters that are inserted automatically.
+ * - `'pattern'` tokens match user input against a regular expression.
+ * - `'any'` tokens accept any single character.
+ */
 export type MaskToken = {
     type: 'literal';
     char: string;
@@ -15,65 +22,183 @@ export type MaskToken = {
     optional?: boolean;
     transform?: (char: string) => string;
 };
+/**
+ * A mask definition that can be a string pattern (e.g., `'999-999'`), an array
+ * of strings, RegExp patterns, or MaskToken objects, or `null` to disable masking.
+ */
 export type Mask = string | Array<string | RegExp | MaskToken> | null;
+/**
+ * Metadata passed to pipe functions during mask conforming.
+ */
 export interface PipeMeta {
+    /** The raw (unmasked) input string. */
     raw: string;
+    /** The previously conformed (masked) value. */
     previousConformed: string;
+    /** The current cursor position. */
     cursor: number;
+    /** Whether all required mask slots have been filled. */
     completed: boolean;
 }
+/**
+ * The return type of a pipe function. Can be:
+ * - A `string` to replace the conformed value.
+ * - An object `{ value, cursor? }` to set both the value and cursor position.
+ * - `false` to reject the input and revert to the previous conformed value.
+ */
 export type PipeResult = string | {
     value: string;
     cursor?: number;
 } | false;
+/**
+ * Options for unmasking a conformed value back to raw form.
+ */
 export interface UnmaskOptions {
+    /**
+     * The unmasking strategy.
+     * - `'none'` - Return the conformed value as-is.
+     * - `'strip'` - Remove all non-alphanumeric characters.
+     * - `'custom'` - Use the provided `unmask` function.
+     * @default 'none'
+     */
     strategy?: 'none' | 'strip' | 'custom';
+    /** Custom unmask function used when `strategy` is `'custom'`. */
     unmask?: (conformed: string) => string;
 }
+/**
+ * Options for determining when a masked input value is considered complete.
+ */
 export interface CompletionOptions {
+    /**
+     * The completion detection mode.
+     * - `'mask'` - Complete when all required mask slots are filled.
+     * - `'min'` - Complete when at least `minChars` slots are filled.
+     * - `'custom'` - Use the provided `isComplete` function.
+     * @default 'mask'
+     */
     mode?: 'mask' | 'min' | 'custom';
+    /** Minimum number of filled characters for `'min'` mode. */
     minChars?: number;
+    /** Custom completion predicate for `'custom'` mode. */
     isComplete?: (conformed: string) => boolean;
 }
+/**
+ * Options controlling cursor positioning behavior within the masked input.
+ */
 export interface CursorBehavior {
+    /**
+     * Cursor placement policy after conforming.
+     * - `'smart'` - Cursor skips past trailing literals after the last filled slot.
+     * - `'sticky'` - Cursor stays immediately after the last filled slot.
+     * @default 'smart'
+     */
     policy?: 'smart' | 'sticky';
+    /**
+     * When `true`, backspace skips over literal characters to delete the
+     * preceding user-entered character.
+     * @default true
+     */
     backspaceRubberBand?: boolean;
 }
+/**
+ * Options for placeholder display within the masked input.
+ */
 export interface PlaceholderOptions {
+    /** Whether to show a guide mask in the input when empty. */
     guide?: boolean;
+    /**
+     * The character used to represent unfilled mask slots.
+     * @default '_'
+     */
     placeholderChar?: string;
+    /** Whether to keep character positions when editing in the middle of the value. */
     keepCharPositions?: boolean;
 }
+/**
+ * A dictionary mapping mask symbol characters to their pattern definitions.
+ * Used to define custom mask tokens (e.g., `'9'` for digits, `'A'` for letters).
+ *
+ * @example
+ * ```ts
+ * const defs: MaskDictionary = {
+ *   '9': { pattern: /^[0-9]$/ },
+ *   'A': { pattern: /^[A-Za-z]$/, transform: c => c.toUpperCase() },
+ * }
+ * ```
+ */
 export interface MaskDictionary {
     [symbol: string]: {
+        /** RegExp pattern that a single character must match. */
         pattern: RegExp;
+        /** Whether this token is optional (not required for completion). */
         optional?: boolean;
+        /** Transform function applied to accepted characters. */
         transform?: (char: string) => string;
     };
 }
+/**
+ * A function that dynamically generates a mask based on the current raw input
+ * and metadata. Useful for inputs where the mask structure depends on what has
+ * been typed so far (e.g., phone numbers with varying formats).
+ */
 export type DynamicMask = (raw: string, meta: PipeMeta) => Mask;
+/**
+ * Low-level configuration options for the masked input engine.
+ * These options control how raw input is conformed to a mask pattern.
+ */
 export interface MaskedInputOptions {
+    /** The current input value. */
     value?: string;
+    /** Default value used when no value is provided. */
     defaultValue?: string;
+    /** The mask pattern or dynamic mask function. */
     mask: Value<Mask | DynamicMask>;
+    /** Custom mask symbol definitions. */
     definitions?: Value<MaskDictionary>;
+    /**
+     * Whether to include the default definitions (`9`, `A`, `*`).
+     * @default true
+     */
     useDefaultDefinitions?: Value<boolean>;
+    /** Placeholder text displayed when the input is empty. */
     placeholder?: Value<string>;
+    /** Options for placeholder guide display. */
     placeholderOptions?: Value<PlaceholderOptions>;
+    /** Extra literal characters to strip from raw input before conforming. */
     extraLiterals?: Value<string[]>;
+    /** A string prepended to the conformed value. */
     prefix?: Value<string>;
+    /** A string appended to the conformed value. */
     suffix?: Value<string>;
+    /**
+     * Auto-fix mode for out-of-range values.
+     * @default 'none'
+     */
     autofix?: Value<'none' | 'pad' | 'truncate'>;
+    /** Whether to clear the input when incomplete on blur. */
     autoclear?: Value<boolean>;
+    /** Cursor positioning behavior configuration. */
     cursor?: Value<CursorBehavior>;
+    /** Post-processing pipe function applied after conforming. */
     pipe?: (conformed: string, meta: PipeMeta) => PipeResult;
+    /** Completion detection configuration. */
     completion?: Value<CompletionOptions>;
+    /** Unmasking configuration for extracting raw values. */
     unmask?: Value<UnmaskOptions>;
+    /**
+     * Character filtering mode.
+     * @default 'all'
+     */
     allowMode?: Value<'all' | 'digits' | 'letters' | 'alphanumeric' | 'custom'>;
+    /** Custom character filter function used with `allowMode: 'custom'`. */
     allow?: (char: string) => boolean;
+    /** Hard maximum character length. */
     maxLengthHard?: Value<number>;
+    /** Debounce delay in milliseconds for change events. */
     debounceMs?: Value<number>;
+    /** Whether to handle IME composition events safely. */
     compositionSafe?: Value<boolean>;
+    /** Callback invoked on every accepted input change. */
     onAccept?: (next: {
         raw: string;
         conformed: string;
@@ -81,14 +206,47 @@ export interface MaskedInputOptions {
         cursor: number;
         numericParsed?: number;
     }) => void;
+    /** Callback invoked when the mask value is fully completed. */
     onComplete?: (finalValue: {
         raw: string;
         conformed: string;
         numericParsed?: number;
     }) => void;
 }
+/**
+ * Options for the {@link MaskInput} component, merging standard `InputOptions<string>`
+ * with masked input configuration. The `value`, `defaultValue`, `onAccept`, and `onComplete`
+ * fields from `MaskedInputOptions` are controlled by `InputOptions` lifecycle.
+ */
 export type MaskInputOptions = Merge<InputOptions<string>, Omit<MaskedInputOptions, 'value' | 'defaultValue' | 'onAccept' | 'onComplete'> & {
     onAccept?: MaskedInputOptions['onAccept'];
     onComplete?: MaskedInputOptions['onComplete'];
 }>;
+/**
+ * A text input component with configurable input masking.
+ *
+ * Supports static and dynamic masks, custom token definitions, cursor behavior
+ * policies, completion detection, pipes for post-processing, and unmask strategies.
+ *
+ * @param options - Configuration options for the masked input.
+ * @returns A renderable masked input component.
+ *
+ * @example
+ * ```ts
+ * // Phone number mask
+ * MaskInput({
+ *   value: prop(''),
+ *   mask: '(999) 999-9999',
+ *   placeholder: '(___) ___-____',
+ *   onChange: v => console.log(v),
+ * })
+ *
+ * // Custom mask with definitions
+ * MaskInput({
+ *   value: prop(''),
+ *   mask: 'AA-9999',
+ *   onChange: v => console.log(v),
+ * })
+ * ```
+ */
 export declare const MaskInput: (options: MaskInputOptions) => Renderable;

package/dist/types/components/form/input/native-select.d.ts

@@ -2,11 +2,61 @@ import { Renderable, Value } from '@tempots/dom';
 import { InputOptions } from './input-options';
 import { BaseControllerOptions, ControllerOptions } from '../control';
 import { SelectOption } from './option';
+/**
+ * Options for the {@link NativeSelect} component.
+ * Extends standard `InputOptions` with native `<select>` element configuration.
+ *
+ * @typeParam T - The type of option values.
+ */
 export type NativeSelectOptions<T> = InputOptions<T> & {
+    /** The list of selectable options. Supports value, group, and break types. */
     options: Value<SelectOption<T>[]>;
+    /** Label for the initial unselected/placeholder option. Defaults to the i18n "Select one" message. */
     unselectedLabel?: Value<string>;
+    /**
+     * Custom equality function for comparing option values.
+     * @default (a, b) => a === b
+     */
     equality?: (a: T, b: T) => boolean;
 };
+/**
+ * A native HTML `<select>` dropdown input component.
+ *
+ * Renders a styled native select element with support for grouped options,
+ * custom equality, and an initial unselected placeholder. The select opens
+ * the browser's native picker on click. Values are tracked via DOM expandos
+ * to support non-string option types.
+ *
+ * @typeParam T - The type of option values.
+ * @param options - Configuration options for the native select.
+ * @returns A renderable native select component.
+ *
+ * @example
+ * ```ts
+ * NativeSelect({
+ *   value: prop('us'),
+ *   options: [
+ *     { type: 'value', value: 'us', label: 'United States' },
+ *     { type: 'value', value: 'uk', label: 'United Kingdom' },
+ *   ],
+ *   onChange: country => console.log('Selected:', country),
+ * })
+ * ```
+ */
 export declare const NativeSelect: <T>(options: NativeSelectOptions<T>) => Renderable;
+/**
+ * A base form control wrapper for {@link NativeSelect} using a raw controller.
+ *
+ * @typeParam T - The type of option values.
+ * @param options - Base controller options for the native select control.
+ * @returns A renderable form control component.
+ */
 export declare function BaseNativeSelectControl<T>(options: BaseControllerOptions<T, NativeSelectOptions<T>>): Renderable;
+/**
+ * A full form control wrapper for {@link NativeSelect} with label, error, and description support.
+ *
+ * @typeParam T - The type of option values.
+ * @param options - Controller options for the native select control.
+ * @returns A renderable form control component with wrapper.
+ */
 export declare function NativeSelectControl<T>(options: ControllerOptions<T, NativeSelectOptions<T>>): Renderable;

package/dist/types/components/form/input/nullable-base64-input.d.ts

@@ -1,8 +1,33 @@
 import { Value } from '@tempots/dom';
 import { type Base64InputOptions } from './base64-input';
+/**
+ * Options for the {@link NullableBase64Input} component.
+ * Extends `Base64InputOptions` but accepts `string | null` for value and callbacks.
+ */
 export type NullableBase64InputOptions = Omit<Base64InputOptions, 'value' | 'onChange' | 'onInput'> & {
+    /** The current base64 value, which may be `null` (no file) or a base64-encoded string. */
     value: Value<string | null>;
+    /** Callback invoked on change with `null` (if cleared) or the base64 string. */
     onChange?: (value: string | null) => void;
+    /** Callback invoked on input with `null` (if cleared) or the base64 string. */
     onInput?: (value: string | null) => void;
 };
+/**
+ * A nullable variant of {@link Base64Input} that maps between `string | null` and `string | undefined`.
+ *
+ * When no file is selected, the value is `null`. Includes a reset button to
+ * clear the value back to `null`. Wraps `Base64Input` with null-handling logic.
+ *
+ * @param options - Configuration options for the nullable base64 input.
+ * @returns A renderable nullable base64 input component.
+ *
+ * @example
+ * ```ts
+ * NullableBase64Input({
+ *   value: prop<string | null>(null),
+ *   accept: 'image/*',
+ *   onChange: v => console.log('Base64:', v), // null or string
+ * })
+ * ```
+ */
 export declare const NullableBase64Input: (options: NullableBase64InputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-bigint-input.d.ts

@@ -1,9 +1,35 @@
 import { Value } from '@tempots/dom';
 import { Merge } from '@tempots/std';
 import { InputOptions } from './input-options';
+/**
+ * Options for the {@link NullableBigintInput} component.
+ * Extends standard `InputOptions` for `bigint | null` values with stepper and range constraints.
+ */
 export type NullableBigintInputOptions = Merge<InputOptions<bigint | null>, {
+    /** Step value for increment/decrement buttons. If provided, stepper buttons are shown. */
     step?: Value<bigint>;
+    /** Minimum allowed value. Values below this are clamped. */
     min?: Value<bigint>;
+    /** Maximum allowed value. Values above this are clamped. */
     max?: Value<bigint>;
 }>;
+/**
+ * A nullable variant of {@link BigintInput} for `bigint | null` values.
+ *
+ * Empty input strings are converted to `null`. Supports optional stepper
+ * buttons, min/max clamping, and a reset button to clear the value to `null`.
+ *
+ * @param options - Configuration options for the nullable bigint input.
+ * @returns A renderable nullable bigint input component.
+ *
+ * @example
+ * ```ts
+ * NullableBigintInput({
+ *   value: prop<bigint | null>(null),
+ *   step: 1n,
+ *   min: 0n,
+ *   onChange: v => console.log('Value:', v), // null or bigint
+ * })
+ * ```
+ */
 export declare const NullableBigintInput: (options: NullableBigintInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-date-input.d.ts

@@ -1,2 +1,20 @@
 import { InputOptions } from './input-options';
+/**
+ * A nullable date input component for `Date | null` values.
+ *
+ * Renders a native HTML `date` input that can be cleared to `null`.
+ * Includes a reset button to clear the value. Uses `valueAsDate` for
+ * direct `Date` object binding.
+ *
+ * @param options - Standard input options for a `Date | null` value.
+ * @returns A renderable nullable date input component.
+ *
+ * @example
+ * ```ts
+ * NullableDateInput({
+ *   value: prop<Date | null>(null),
+ *   onChange: date => console.log('Date:', date),
+ * })
+ * ```
+ */
 export declare const NullableDateInput: (options: InputOptions<Date | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-date-time-input.d.ts

@@ -1,2 +1,21 @@
 import { InputOptions } from './input-options';
+/**
+ * A nullable date-time input component for `Date | null` values.
+ *
+ * Renders a native HTML `datetime-local` input that can be cleared to `null`.
+ * Converts `Date` objects to the `YYYY-MM-DDTHH:MM:SS` format for display
+ * and parses input back to `Date` objects. Includes a reset button to clear
+ * the value.
+ *
+ * @param options - Standard input options for a `Date | null` value.
+ * @returns A renderable nullable date-time input component.
+ *
+ * @example
+ * ```ts
+ * NullableDateTimeInput({
+ *   value: prop<Date | null>(new Date()),
+ *   onChange: date => console.log('DateTime:', date),
+ * })
+ * ```
+ */
 export declare const NullableDateTimeInput: (options: InputOptions<Date | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-duration-input.d.ts

@@ -1,3 +1,22 @@
 import { InputOptions } from './input-options';
 import type { Duration } from '../../../temporal/types';
+/**
+ * A nullable variant of {@link DurationInput} for `Duration | null` values.
+ *
+ * Accepts ISO-8601 duration strings (e.g., `P1DT2H30M`). Empty input is
+ * converted to `null`. Includes a reset button to clear the value. Shows a
+ * fallback plain text input while the Temporal polyfill is loading, then
+ * upgrades to the full masked input.
+ *
+ * @param options - Standard input options for a `Duration | null` value.
+ * @returns A renderable nullable duration input component.
+ *
+ * @example
+ * ```ts
+ * NullableDurationInput({
+ *   value: prop<Duration | null>(null),
+ *   onChange: d => console.log('Duration:', d?.toString() ?? 'null'),
+ * })
+ * ```
+ */
 export declare const NullableDurationInput: (options: InputOptions<Duration | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-email-input.d.ts

@@ -1 +1,19 @@
+/**
+ * A nullable variant of {@link EmailInput} that maps between `string | null` and `string`.
+ *
+ * Empty strings are converted to `null` on change, and `null` values are displayed
+ * as empty strings. Includes a reset button to clear the value back to `null`.
+ *
+ * @param options - Standard input options for a `string | null` value.
+ * @returns A renderable nullable email input component.
+ *
+ * @example
+ * ```ts
+ * NullableEmailInput({
+ *   value: prop<string | null>(null),
+ *   placeholder: 'Enter email or leave empty...',
+ *   onChange: v => console.log('Email:', v), // null or string
+ * })
+ * ```
+ */
 export declare const NullableEmailInput: (options: import("./input-options").InputOptions<null | string>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-instant-input.d.ts

@@ -1,3 +1,22 @@
 import { InputOptions } from './input-options';
 import { Instant } from '../../../temporal';
+/**
+ * A nullable variant of {@link InstantInput} for `Instant | null` values.
+ *
+ * Renders a `datetime-local` HTML input that can be cleared to `null`.
+ * Converts `Instant` to local date-time for display and parses input back
+ * via ISO string conversion. Includes a reset button to clear the value.
+ * Requires the Temporal polyfill.
+ *
+ * @param options - Standard input options for an `Instant | null` value.
+ * @returns A renderable nullable instant input component.
+ *
+ * @example
+ * ```ts
+ * NullableInstantInput({
+ *   value: prop<Instant | null>(null),
+ *   onChange: instant => console.log('Instant:', instant?.toString() ?? 'null'),
+ * })
+ * ```
+ */
 export declare const NullableInstantInput: (options: InputOptions<Instant | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-mask-input.d.ts

@@ -1,5 +1,29 @@
 import { Merge } from '@tempots/dom';
 import { InputOptions } from './input-options';
 import { MaskInputOptions } from './mask-input';
+/**
+ * Options for the {@link NullableMaskInput} component.
+ * Merges nullable string `InputOptions` with `MaskInputOptions` (excluding value/change handlers).
+ */
 export type NullableMaskInputOptions = Merge<InputOptions<null | string>, Omit<MaskInputOptions, 'value' | 'onChange' | 'onInput'>>;
+/**
+ * A nullable variant of {@link MaskInput} for `string | null` values.
+ *
+ * Empty strings are converted to `null` on change, and `null` values are
+ * displayed as empty strings. Includes a reset button to clear the value.
+ * Supports all mask configuration options from `MaskInputOptions`.
+ *
+ * @param options - Configuration options for the nullable mask input.
+ * @returns A renderable nullable mask input component.
+ *
+ * @example
+ * ```ts
+ * NullableMaskInput({
+ *   value: prop<string | null>(null),
+ *   mask: '(999) 999-9999',
+ *   placeholder: '(___) ___-____',
+ *   onChange: v => console.log('Phone:', v), // null or string
+ * })
+ * ```
+ */
 export declare const NullableMaskInput: (options: NullableMaskInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-number-input.d.ts

@@ -1,9 +1,38 @@
 import { Value } from '@tempots/dom';
 import { InputOptions } from './input-options';
 import { Merge } from '@tempots/std';
+/**
+ * Options for the {@link NullableNumberInput} component.
+ * Extends standard `InputOptions` for `number | null` values with stepper and range constraints.
+ */
 export type NullableNumberInputOptions = Merge<InputOptions<number | null>, {
+    /** Step value for increment/decrement buttons and mouse wheel. If provided, stepper buttons are shown. */
     step?: Value<number>;
+    /** Minimum allowed value. Values below this are clamped. */
     min?: Value<number>;
+    /** Maximum allowed value. Values above this are clamped. */
     max?: Value<number>;
 }>;
+/**
+ * A nullable number input component for `number | null` values.
+ *
+ * Renders a native HTML `number` input that can be cleared to `null`.
+ * Supports optional stepper buttons, min/max clamping, mouse wheel
+ * increment/decrement (with Shift for 10x), and a reset button to
+ * clear the value to `null`.
+ *
+ * @param options - Configuration options for the nullable number input.
+ * @returns A renderable nullable number input component.
+ *
+ * @example
+ * ```ts
+ * NullableNumberInput({
+ *   value: prop<number | null>(null),
+ *   step: 1,
+ *   min: 0,
+ *   max: 100,
+ *   onChange: v => console.log('Value:', v), // null or number
+ * })
+ * ```
+ */
 export declare const NullableNumberInput: (options: NullableNumberInputOptions) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-password-input.d.ts

@@ -1 +1,19 @@
+/**
+ * A nullable variant of {@link PasswordInput} that maps between `string | null` and `string`.
+ *
+ * Empty strings are converted to `null` on change, and `null` values are displayed
+ * as empty strings. Includes a reset button to clear the value back to `null`.
+ *
+ * @param options - Standard input options for a `string | null` value.
+ * @returns A renderable nullable password input component.
+ *
+ * @example
+ * ```ts
+ * NullablePasswordInput({
+ *   value: prop<string | null>(null),
+ *   placeholder: 'Enter password or leave empty...',
+ *   onChange: v => console.log('Password:', v != null ? '***' : 'null'),
+ * })
+ * ```
+ */
 export declare const NullablePasswordInput: (options: import("./input-options").InputOptions<null | string>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-date-input.d.ts

@@ -1,3 +1,21 @@
+/**
+ * A nullable variant of {@link PlainDateInput} for `PlainDate | null` values.
+ *
+ * Renders a native HTML `date` input that can be cleared to `null`.
+ * Created via {@link createNullableTemporalInput} with `PlainDate` serialization.
+ * Includes a reset button to clear the value. Requires the Temporal polyfill.
+ *
+ * @param options - Standard input options for a `PlainDate | null` value.
+ * @returns A renderable nullable plain date input component.
+ *
+ * @example
+ * ```ts
+ * NullablePlainDateInput({
+ *   value: prop<PlainDate | null>(null),
+ *   onChange: date => console.log('Date:', date?.toString() ?? 'null'),
+ * })
+ * ```
+ */
 export declare const NullablePlainDateInput: (options: {
     autocomplete?: import("@tempots/dom").Value<string> | undefined;
     autofocus?: import("@tempots/dom").Value<boolean> | undefined;

package/dist/types/components/form/input/nullable-plain-date-time-input.d.ts

@@ -1,3 +1,21 @@
+/**
+ * A nullable variant of {@link PlainDateTimeInput} for `PlainDateTime | null` values.
+ *
+ * Renders a native HTML `datetime-local` input that can be cleared to `null`.
+ * Created via {@link createNullableTemporalInput} with `PlainDateTime` serialization.
+ * Includes a reset button to clear the value. Requires the Temporal polyfill.
+ *
+ * @param options - Standard input options for a `PlainDateTime | null` value.
+ * @returns A renderable nullable plain date-time input component.
+ *
+ * @example
+ * ```ts
+ * NullablePlainDateTimeInput({
+ *   value: prop<PlainDateTime | null>(null),
+ *   onChange: dt => console.log('DateTime:', dt?.toString() ?? 'null'),
+ * })
+ * ```
+ */
 export declare const NullablePlainDateTimeInput: (options: {
     autocomplete?: import("@tempots/dom").Value<string> | undefined;
     autofocus?: import("@tempots/dom").Value<boolean> | undefined;

package/dist/types/components/form/input/nullable-plain-month-day-input.d.ts

@@ -1,3 +1,21 @@
 import { InputOptions } from './input-options';
 import { PlainMonthDay } from '../../../temporal';
+/**
+ * A nullable variant of {@link PlainMonthDayInput} for `PlainMonthDay | null` values.
+ *
+ * Uses a masked text input with the pattern `MM-DD` that can be cleared to `null`.
+ * Empty input is converted to `null`. Includes a reset button to clear the value.
+ * Requires the Temporal polyfill.
+ *
+ * @param options - Standard input options for a `PlainMonthDay | null` value.
+ * @returns A renderable nullable plain month-day input component.
+ *
+ * @example
+ * ```ts
+ * NullablePlainMonthDayInput({
+ *   value: prop<PlainMonthDay | null>(null),
+ *   onChange: md => console.log('MonthDay:', md?.toString() ?? 'null'),
+ * })
+ * ```
+ */
 export declare const NullablePlainMonthDayInput: (options: InputOptions<PlainMonthDay | null>) => import("@tempots/dom").Renderable;

package/dist/types/components/form/input/nullable-plain-time-input.d.ts

@@ -1,3 +1,21 @@
+/**
+ * A nullable variant of {@link PlainTimeInput} for `PlainTime | null` values.
+ *
+ * Renders a native HTML `time` input that can be cleared to `null`.
+ * Created via {@link createNullableTemporalInput} with `PlainTime` serialization.
+ * Includes a reset button to clear the value. Requires the Temporal polyfill.
+ *
+ * @param options - Standard input options for a `PlainTime | null` value.
+ * @returns A renderable nullable plain time input component.
+ *
+ * @example
+ * ```ts
+ * NullablePlainTimeInput({
+ *   value: prop<PlainTime | null>(null),
+ *   onChange: time => console.log('Time:', time?.toString() ?? 'null'),
+ * })
+ * ```
+ */
 export declare const NullablePlainTimeInput: (options: {
     autocomplete?: import("@tempots/dom").Value<string> | undefined;
     autofocus?: import("@tempots/dom").Value<boolean> | undefined;