@ostack.tech/ui-kform 0.1.0

package/dist/types/components/Annexes/Annex.d.ts

@@ -0,0 +1,46 @@
+import { type Path } from "@ostack.tech/kform";
+import { ErrorBoundary, TabContent } from "@ostack.tech/ui";
+import * as React from "react";
+import { type IssueMessagesByCode } from "../IssueMessages";
+/** Properties of the annex component. */
+export interface AnnexProps extends Omit<React.ComponentPropsWithoutRef<typeof TabContent>, "value" | "children"> {
+    /** Annex path. This should match the path of the annex provided to `Annexes`. */
+    path?: string | Path;
+    /** Sets the annex as disabled. */
+    disabled?: boolean;
+    /** Sets the annex as read-only. */
+    readOnly?: boolean;
+    /**
+     * Mapping of issue messages from the path of the field with issues to the
+     * issue messages of said field (which are themselves grouped by their code).
+     *
+     * Provided paths are relative to the annex's path and may contain wildcards,
+     * which will have a lower priority when matched against.
+     *
+     * These messages are used by the `IssueMessages` component.
+     *
+     * **Note:** Changes to `issueMessages` are handled correctly, but are not
+     * efficient. Please make sure that the identity of the provided value doesn't
+     * change at every render.
+     *
+     * Example value:
+     *
+     * ```tsx
+     * {
+     *   "**": {
+     *     "valueMissing": "Field is required."
+     *   },
+     *   "field": {
+     *     "valueMissing": "My field cannot be left empty!",
+     *     "someOtherError": "Text of the other error."
+     *   }
+     * }
+     * ```
+     */
+    issueMessages?: Record<string, IssueMessagesByCode>;
+    /** Properties to pass to the `ErrorBoundary` component. */
+    errorBoundaryProps?: React.ComponentPropsWithRef<typeof ErrorBoundary>;
+    children?: React.ReactNode;
+}
+/** Component containing the content of an annex. */
+export declare const Annex: React.ForwardRefExoticComponent<AnnexProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/Annexes/AnnexTab.d.ts

@@ -0,0 +1,5 @@
+import { type AbsolutePath } from "@ostack.tech/kform";
+export interface AnnexTabProps {
+    path: AbsolutePath;
+}
+export declare function AnnexTab({ path }: AnnexTabProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annexes/Annexes.d.ts

@@ -0,0 +1,95 @@
+import { type AbsolutePath, type Path } from "@ostack.tech/kform";
+import { Tabs } from "@ostack.tech/ui";
+import * as React from "react";
+/** Properties of the annexes component. */
+export interface AnnexesProps extends Omit<React.ComponentPropsWithoutRef<typeof Tabs>, "defaultValue" | "value" | "onValueChange"> {
+    /** Base path for all declared annexes. */
+    path?: string | Path;
+    /** List of all annexes. */
+    annexes: AnnexObject[];
+    /** Default active annex. */
+    defaultActiveAnnex?: string | Path;
+    /** Controlled active annex. */
+    activeAnnex?: string | Path;
+    /**
+     * Function called whenever the active annex changes.
+     *
+     * @param activeAnnex Path of the new active annex.
+     */
+    onActiveAnnexChange?: (activeAnnexPath: AbsolutePath | null) => void;
+    /**
+     * Function called when a new annex is added.
+     *
+     * @param newAnnexPath Path of the new annex.
+     */
+    onAnnexAdd?: (newAnnexPath: AbsolutePath) => void;
+    /**
+     * Function called when an annex is removed.
+     *
+     * @param removedAnnexPath Path of the removed annex.
+     */
+    onAnnexRemove?: (removedAnnexPath: AbsolutePath) => void;
+    children?: React.ReactNode;
+}
+/** Object representation of an annex. */
+export interface AnnexObject<T = any> {
+    /**
+     * Annex path. This path may contain a single wildcard (`*`) at the end, when
+     * the elements of a collection should be counted as annexes. Otherwise, the
+     * path may contain no other wildcards.
+     */
+    path: string | Path;
+    /** Annex's title. */
+    title: React.ReactNode | ((value: T) => React.ReactNode);
+    /** Annex's subtitle. */
+    subtitle?: React.ReactNode | ((value: T, index?: number) => React.ReactNode);
+    /** Annex's description. */
+    description?: React.ReactNode;
+    /**
+     * Annex's label in the issues panel. The `title` and `subtitle` are used by
+     * default.
+     */
+    issuesPanelLabel?: React.ReactNode | ((value: T) => React.ReactNode);
+    itemTitle?: React.ReactNode | ((value: T, index: number) => React.ReactNode);
+    /**
+     * Issues panel label for each annex of a collection of annexes. The
+     * `subtitle` and index of the item are used by default.
+     */
+    itemIssuesPanelLabel?: React.ReactNode | ((value: T, index: number) => React.ReactNode);
+    /**
+     * Title of the annex as a string to display in the document's title.
+     *
+     * Defaults to the `title` together with the `subtitle` (if it exists) when
+     * they are strings.
+     *
+     * A warning is printed if either the title or the subtitle are defined but
+     * aren't strings and `documentTitle` is not provided.
+     */
+    documentTitle?: string | null | ((value: T, index?: number) => string | null);
+    /**
+     * Maximum number of annexes matching this path that can be added, when
+     * counting collection elements as annexes. By default, if the collection has
+     * a `MaxSize` validation, then its value is used.
+     */
+    maxAnnexes?: number;
+    /**
+     * Function called when an annex matching this path is being added to choose
+     * the value that should be added.
+     *
+     * The default value being added is provided as an argument and may be edited
+     * if required.
+     *
+     * The value to be added should be returned, or a promise that resolves with
+     * said value.
+     *
+     * To prevent an annex from being added, return `undefined`/`null` (or a
+     * promise which resolves with `undefined`/`null`).
+     *
+     * @param value - Value being added, can be edited.
+     * @returns Value to be added, `undefined`/`null` if the annex shouldn't be
+     *   added (or a promise that resolves with said values).
+     */
+    getValue?: (value: T) => T | null | undefined | Promise<T | null | undefined>;
+}
+/** Root component used to render form annexes. */
+export declare const Annexes: React.ForwardRefExoticComponent<AnnexesProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/Annexes/AnnexesContext.d.ts

@@ -0,0 +1,87 @@
+import { AbsolutePath, type DisplayStatus, type FormManager, type Path, type Schema, type SealedValidationIssue, type TableRowId } from "@ostack.tech/kform";
+import * as React from "react";
+import { type AnnexesProps, type AnnexObject } from "./Annexes.tsx";
+/** Value of the annexes' context. */
+export type AnnexesContextValue = AnnexesStore;
+/** Resolved annex object. */
+export interface ResolvedAnnexObject extends AnnexObject {
+    path: AbsolutePath;
+}
+/** Annex state. */
+export interface AnnexState {
+    path: AbsolutePath;
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    description?: React.ReactNode;
+    documentTitle?: string | null;
+    isRepetitive: boolean;
+    schema: Schema;
+    isNull: boolean;
+    dirty: boolean | undefined;
+    deferredDisplayStatus: DisplayStatus | undefined;
+    deferredIssuesToDisplay: SealedValidationIssue[];
+}
+/** Repetitive annex state. */
+export type RepetitiveAnnexState = Pick<ResolvedAnnexObject, "path" | "maxAnnexes"> & {
+    rowIds?: TableRowId[];
+    schema: Schema;
+    deferredIssuesToDisplay: SealedValidationIssue[];
+};
+/** State of the annexes. */
+export interface AnnexesState {
+    annexes: ResolvedAnnexObject[];
+    activeAnnex: AbsolutePath | null;
+    nextActiveAnnex: AbsolutePath | null;
+    activeAnnexIndex: () => number;
+    annexStates: [Record<string, AnnexState | null>];
+    repetitiveAnnexStates: [Record<string, RepetitiveAnnexState | null>];
+    tabStates: () => AnnexState[];
+    tablessStates: () => (AnnexState | RepetitiveAnnexState)[];
+    waitingRegistration: () => AbsolutePath[];
+    actions: AnnexesActions;
+}
+/** Actions of the annexes. */
+export interface AnnexesActions {
+    getAnnexState: (path: AbsolutePath) => AnnexState | null;
+    getRepetitiveAnnexState: (path: AbsolutePath) => RepetitiveAnnexState | null;
+    setAnnexes: (annexes: ResolvedAnnexObject[]) => void;
+    buildAnnexStates: (annexes?: ResolvedAnnexObject[]) => Record<string, AnnexState | null>;
+    buildRepetitiveAnnexStates: (annexes?: ResolvedAnnexObject[]) => Record<string, RepetitiveAnnexState | null>;
+    setActiveAnnex: (activeAnnex: string | Path | null) => void;
+    updateActiveAnnex: (oldActiveAnnexIndex: number) => void;
+    registerAnnexState: (path: AbsolutePath, state: AnnexState) => void;
+    registerRepetitiveAnnexState: (path: AbsolutePath, state: RepetitiveAnnexState) => void;
+    addAnnex: (path: AbsolutePath, toAdd: unknown) => Promise<void>;
+    removeAnnex: (path: AbsolutePath, isRepetitive: boolean) => Promise<void>;
+}
+/** Annexes' store. */
+export type AnnexesStore = ReturnType<typeof useCreateAnnexesContext>;
+/** Annexes' context. */
+export declare const AnnexesContext: React.Context<(Omit<import("zustand").StoreApi<AnnexesState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: AnnexesState, previousSelectedState: AnnexesState) => void): () => void;
+        <U>(selector: (state: AnnexesState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}) | null>;
+/** Options used to create the annexes' context. */
+export interface UseCreateAnnexesContextOptions extends Pick<AnnexesProps, "defaultActiveAnnex" | "activeAnnex" | "onActiveAnnexChange" | "onAnnexAdd" | "onAnnexRemove"> {
+    formManager: FormManager;
+    basePath: AbsolutePath;
+    resolvedAnnexes: ResolvedAnnexObject[];
+}
+/** Hook used to create the annexes' context. */
+export declare function useCreateAnnexesContext({ formManager, basePath, resolvedAnnexes, defaultActiveAnnex, activeAnnex, onActiveAnnexChange, onAnnexAdd, onAnnexRemove, }: UseCreateAnnexesContextOptions): Omit<import("zustand").StoreApi<AnnexesState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: AnnexesState, previousSelectedState: AnnexesState) => void): () => void;
+        <U>(selector: (state: AnnexesState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+};
+/** Returns the annexes' context. */
+export declare function useAnnexesContext(): AnnexesContextValue;
+export declare function useAnnexState<T>(path: AbsolutePath, selector: (state: AnnexState | null) => T): T;

package/dist/types/components/Annexes/AnnexesManager.d.ts

@@ -0,0 +1,47 @@
+import { type Button, type DropdownMenu, type DropdownMenuContent, type TabList } from "@ostack.tech/ui";
+import * as React from "react";
+/** Properties of the annexes' manager component. */
+export interface AnnexesManagerProps extends React.ComponentPropsWithoutRef<"nav"> {
+    /** Text of the menu button. */
+    menuButtonText?: React.ReactNode;
+    /** Text of the "add annex" item. */
+    addAnnexText?: React.ReactNode;
+    /** Label of the remove annex button, announced by assistive technologies. */
+    removeAnnexButtonLabel?: string;
+    /**
+     * Hint on how to remove an annex via keyboard, announced by assistive
+     * technologies.
+     */
+    removeAnnexKeyboardHint?: string;
+    /** Title of the "remove annex" confirm dialog. */
+    removeAnnexConfirmDialogTitle?: React.ReactNode;
+    /**
+     * Function that should return the message of the "remove annex" confirm
+     * dialog, given a node with the name of the annex.
+     *
+     * @param annexName Node containing the name of the annex.
+     */
+    removeAnnexConfirmDialogMessage?: (annexName: React.ReactNode) => React.ReactNode;
+    /** Text of the "remove annex" confirm dialog OK button. */
+    removeAnnexConfirmDialogOkText?: React.ReactNode;
+    /** Text of the "remove annex" confirm dialog cancel button. */
+    removeAnnexConfirmDialogCancelText?: React.ReactNode;
+    /** Properties to pass to the menu container element. */
+    menuContainerProps?: React.ComponentPropsWithRef<"div">;
+    /** Properties to pass to the menu trigger component. */
+    menuTriggerProps?: Omit<React.ComponentPropsWithRef<typeof Button>, "icon">;
+    /** Properties to pass to the menu content component. */
+    menuContentProps?: React.ComponentPropsWithRef<typeof DropdownMenuContent>;
+    /** Properties to pass to the menu component. */
+    menuProps?: React.ComponentPropsWithRef<typeof DropdownMenu>;
+    /** Properties to pass to the tab-list container element. */
+    tabListContainerProps?: React.ComponentPropsWithRef<"div">;
+    /** Properties to pass to the tab-list component. */
+    tabListProps?: React.ComponentPropsWithRef<typeof TabList>;
+}
+/**
+ * Component used to manage the form's annexes. Provides a menu that allows
+ * changing, adding, and removing annexes, as well as a list of tabs for each
+ * existing annex.
+ */
+export declare const AnnexesManager: React.ForwardRefExoticComponent<AnnexesManagerProps & React.RefAttributes<HTMLElement>>;

package/dist/types/components/Annexes/AnnexesMenu.d.ts

@@ -0,0 +1,10 @@
+import { Button, DropdownMenu, DropdownMenuContent } from "@ostack.tech/ui";
+import * as React from "react";
+import { type AnnexesManager } from "./AnnexesManager.tsx";
+/** Properties of the annexes' menu. */
+export interface AnnexesMenuProps extends Pick<React.ComponentPropsWithoutRef<typeof AnnexesManager>, "menuButtonText" | "addAnnexText" | "removeAnnexButtonLabel" | "removeAnnexKeyboardHint" | "removeAnnexConfirmDialogTitle" | "removeAnnexConfirmDialogMessage" | "removeAnnexConfirmDialogOkText" | "removeAnnexConfirmDialogCancelText">, React.ComponentPropsWithoutRef<typeof DropdownMenu> {
+    menuTriggerProps?: Omit<React.ComponentPropsWithRef<typeof Button>, "icon">;
+    menuContentProps?: React.ComponentPropsWithRef<typeof DropdownMenuContent>;
+}
+/** Component that allows to navigate between, add, and remove annexes. */
+export declare function AnnexesMenu({ menuButtonText, addAnnexText, removeAnnexButtonLabel, removeAnnexKeyboardHint, removeAnnexConfirmDialogTitle, removeAnnexConfirmDialogMessage, removeAnnexConfirmDialogOkText, removeAnnexConfirmDialogCancelText, defaultOpen, open: controlledOpen, onOpenChange, menuTriggerProps, menuContentProps, ...otherProps }: AnnexesMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annexes/AnnexesTabList.d.ts

@@ -0,0 +1,8 @@
+import { TabList } from "@ostack.tech/ui";
+import * as React from "react";
+/** Properties of the annex tab list component. */
+export interface AnnexTabListProps extends React.ComponentPropsWithoutRef<typeof TabList> {
+    hideNonActiveOnSmallScreens: boolean;
+}
+/** List of annex tabs. */
+export declare const AnnexesTabList: React.ForwardRefExoticComponent<AnnexTabListProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/Annexes/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Annex.tsx";
+export * from "./Annexes.tsx";
+export * from "./AnnexesManager.tsx";

package/dist/types/components/CheckboxControl/CheckboxControl.d.ts

@@ -0,0 +1,48 @@
+import { type Path } from "@ostack.tech/kform";
+import { type InputController, type InputOptions } from "@ostack.tech/kform-react";
+import { Checkbox, type CheckboxChecked } from "@ostack.tech/ui";
+import * as React from "react";
+import { type IssueMessages, type IssueMessagesByCode } from "../IssueMessages";
+/** Properties of the checkbox control component. */
+export interface CheckboxControlProps<T extends boolean | null = boolean | null> extends Omit<InputOptions<T, CheckboxChecked, React.ComponentRef<typeof Checkbox>>, "enabled" | "format" | "parse">, Omit<React.ComponentPropsWithoutRef<typeof Checkbox>, "defaultChecked" | "checked" | "status"> {
+    /** Path to the value. */
+    path?: string | Path;
+    /**
+     * Issue messages of this control.
+     *
+     * Mapping from an issue's code to its message.
+     */
+    issueMessages?: IssueMessagesByCode;
+    /**
+     * Label to use in the issues panel when displaying issues associated with
+     * this field.
+     *
+     * This label has priority over the field's `ControlLabel`.
+     */
+    issuesPanelLabel?: React.ReactNode;
+    /**
+     * Whether to display the issues associated with this control.
+     *
+     * @default true
+     */
+    displayIssues?: boolean;
+    /**
+     * Whether to prevent the auto-focusing behaviour that causes this control to
+     * be focused when the form app's `focus` is called with this control's path.
+     *
+     * Preventing this behaviour is useful when multiple controls for the same
+     * path are rendered at once, and only one of them should be focused.
+     *
+     * @default false
+     */
+    preventAutoFocus?: boolean;
+    /** Reference to the control's API. */
+    apiRef?: React.Ref<InputController<T, CheckboxChecked, React.ComponentRef<typeof Checkbox>> | undefined>;
+    /** Properties to pass to the `IssueMessages` component. */
+    issueMessagesProps?: Omit<React.ComponentPropsWithRef<typeof IssueMessages>, "path" | "issues" | "messages" | "unwrapped">;
+}
+/**
+ * Checkbox control component supporting (possibly nullable) schemas of type
+ * "Boolean". `null` values are represented as an "indeterminate" checkbox.
+ */
+export declare const CheckboxControl: React.ForwardRefExoticComponent<CheckboxControlProps<boolean | null> & React.RefAttributes<HTMLButtonElement>>;

package/dist/types/components/CheckboxControl/index.d.ts

@@ -0,0 +1 @@
+export * from "./CheckboxControl.tsx";

package/dist/types/components/CheckboxGroupControl/CheckboxGroupControl.d.ts

@@ -0,0 +1,63 @@
+import { type Path } from "@ostack.tech/kform";
+import { type Listable, type ListableInputController, type ListableInputOptions } from "@ostack.tech/kform-react";
+import { Checkbox, CheckboxGroup } from "@ostack.tech/ui";
+import * as React from "react";
+import { type IssueMessages, type IssueMessagesByCode } from "../IssueMessages";
+/** Checkbox in object notation. */
+export type CheckboxObject<T = unknown> = Omit<React.ComponentPropsWithRef<typeof Checkbox>, "defaultChecked" | "checked" | "value" | "children"> & {
+    /** Option value. */
+    value: T;
+    /** Option's rendered text. */
+    text?: React.ReactNode;
+    /** Option's unique key. */
+    key?: React.Key;
+};
+/** Properties of the checkbox group control component. */
+export interface CheckboxGroupControlProps<T = unknown, TListable extends Listable<T> | null = Listable<T> | null> extends Omit<ListableInputOptions<T, TListable, string[], React.ComponentRef<typeof CheckboxGroup>>, "enabled" | "formatFromArray" | "parseToArray">, Omit<React.ComponentPropsWithoutRef<typeof CheckboxGroup>, "defaultValue" | "value" | "onValueChange" | "children" | "status"> {
+    /** Path to the value. */
+    path?: string | Path;
+    /** Checkbox group control options. */
+    options: CheckboxObject<T>[];
+    /**
+     * Issue messages of this control.
+     *
+     * Mapping from an issue's code to its message.
+     */
+    issueMessages?: IssueMessagesByCode;
+    /**
+     * Label to use in the issues panel when displaying issues associated with
+     * this field.
+     *
+     * This label has priority over the field's `ControlLabel`.
+     */
+    issuesPanelLabel?: React.ReactNode;
+    /**
+     * Whether to display the issues associated with this control.
+     *
+     * @default true
+     */
+    displayIssues?: boolean;
+    /**
+     * Whether to prevent the auto-focusing behaviour that causes this control to
+     * be focused when the form app's `focus` is called with this control's path.
+     *
+     * Preventing this behaviour is useful when multiple controls for the same
+     * path are rendered at once, and only one of them should be focused.
+     *
+     * @default false
+     */
+    preventAutoFocus?: boolean;
+    /** Reference to the control's API. */
+    apiRef?: React.Ref<ListableInputController<T, TListable, string[], React.ComponentRef<typeof CheckboxGroup>> | undefined>;
+    /** Properties to pass to the `IssueMessages` component. */
+    issueMessagesProps?: Omit<React.ComponentPropsWithRef<typeof IssueMessages>, "path" | "issues" | "messages" | "unwrapped">;
+}
+/**
+ * Checkbox group control component supporting (possibly nullable) listable
+ * schemas with elements of any type.
+ *
+ * If the schema is nullable, this component sets the form value to `null` when
+ * the control contains no elements. Note, however, that the form may still hold
+ * an empty listable as value if set programmatically.
+ */
+export declare const CheckboxGroupControl: React.ForwardRefExoticComponent<CheckboxGroupControlProps<unknown, Listable<unknown> | null> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/CheckboxGroupControl/index.d.ts

@@ -0,0 +1 @@
+export * from "./CheckboxGroupControl.tsx";

package/dist/types/components/ControlField/ControlField.d.ts

@@ -0,0 +1,50 @@
+import { Path } from "@ostack.tech/kform";
+import { Field } from "@ostack.tech/ui";
+import * as React from "react";
+/** Properties of the control field component. */
+export interface ControlFieldProps extends React.ComponentPropsWithoutRef<typeof Field> {
+    /** Path of the field; inner control paths will be relative to this path. */
+    path?: string | Path;
+    /**
+     * Whether to show the control field.
+     *
+     * The component will, by default, automatically reset its inner controls when
+     * the control field becomes hidden.
+     *
+     * @default true
+     */
+    shown?: boolean;
+    /**
+     * Whether to reset the inner controls when the control field becomes hidden.
+     *
+     * @default true
+     */
+    resetOnHide?: boolean;
+    /**
+     * Whether to set inner controls as untouched when the control field becomes
+     * hidden.
+     *
+     * @default resetOnHide
+     */
+    setUntouchedOnHide?: boolean;
+    /**
+     * Whether to set inner controls as pristine when the control field becomes
+     * hidden.
+     *
+     * @default resetOnHide
+     */
+    setPristineOnHide?: boolean;
+}
+/**
+ * Component used to group controls with a label, helper text, and/or feedback.
+ *
+ * The component can be conditionally shown via the `shown` property which, by
+ * default, when changing from `true` to `false` will reset its inner controls.
+ *
+ * Added labels automatically "point" to the control and are set to "required"
+ * when requested by the control.
+ *
+ * Aria descriptions and error messages are set on the control based on the
+ * provided helper texts or feedbacks.
+ */
+export declare const ControlField: React.ForwardRefExoticComponent<ControlFieldProps & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/ControlField/ControlFieldContext.d.ts

@@ -0,0 +1,33 @@
+import { type AbsolutePath, type FormManager, type Schema, type SealedValidationIssue } from "@ostack.tech/kform";
+import { type Controller } from "@ostack.tech/kform-react";
+import * as React from "react";
+/** Value of the control field context. */
+export type ControlFieldContextValue = ControlFieldStore;
+/** State of the control field. */
+export interface ControlFieldState {
+    controlStates: Record<string, ControlState>;
+}
+/** State of a control accessible to the whole field. */
+export interface ControlState {
+    formManager: FormManager;
+    schema: Schema;
+    path: AbsolutePath;
+    exists: boolean;
+    deferredIssuesToDisplay: SealedValidationIssue[];
+}
+/** Control field store. */
+export type ControlFieldStore = ReturnType<typeof useCreateControlFieldContext>;
+/** Control field context. */
+export declare const ControlFieldContext: React.Context<import("zustand").StoreApi<ControlFieldState> | null>;
+/** Hook which creates the control field context value. */
+export declare function useCreateControlFieldContext(): import("zustand").StoreApi<ControlFieldState>;
+/** Hook that returns access to the control field's store. */
+export declare function useControlFieldStore<T>(selector: (state: Partial<ControlFieldState>) => T): T;
+/** Hook exposing whether a component is being rendered within a control field. */
+export declare function useIsInControlField(): boolean;
+/**
+ * Hook that makes a control field aware of a controller.
+ *
+ * The passed `controller` object should not be different on every render.
+ */
+export declare function useRegisterControllerWithinControlField<T = unknown>(controller: Controller<T>, deferredIssuesToDisplay: SealedValidationIssue[]): void;

package/dist/types/components/ControlField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ControlField.tsx";
+export { useIsInControlField, useRegisterControllerWithinControlField, } from "./ControlFieldContext.ts";

package/dist/types/components/DateControl/DateControl.d.ts

@@ -0,0 +1,45 @@
+import { type Path } from "@ostack.tech/kform";
+import { type Temporal, type TemporalInputController, type TemporalInputOptions } from "@ostack.tech/kform-react";
+import { DateInput } from "@ostack.tech/ui";
+import * as React from "react";
+import { type IssueMessages, type IssueMessagesByCode } from "../IssueMessages";
+/** Properties of the date control component. */
+export interface DateControlProps<T extends Temporal | null = Temporal | null> extends Omit<TemporalInputOptions<T, string, React.ComponentRef<typeof DateInput>>, "enabled" | "formatFromString" | "parseToString">, Omit<React.ComponentPropsWithoutRef<typeof DateInput>, "defaultValue" | "value" | "onValueChange" | "status"> {
+    /** Path to the value. */
+    path?: string | Path;
+    /**
+     * Issue messages of this control.
+     *
+     * Mapping from an issue's code to its message.
+     */
+    issueMessages?: IssueMessagesByCode;
+    /**
+     * Label to use in the issues panel when displaying issues associated with
+     * this field.
+     *
+     * This label has priority over the field's `ControlLabel`.
+     */
+    issuesPanelLabel?: React.ReactNode;
+    /**
+     * Whether to display the issues associated with this control.
+     *
+     * @default true
+     */
+    displayIssues?: boolean;
+    /**
+     * Whether to prevent the auto-focusing behaviour that causes this control to
+     * be focused when the form app's `focus` is called with this control's path.
+     *
+     * Preventing this behaviour is useful when multiple controls for the same
+     * path are rendered at once, and only one of them should be focused.
+     *
+     * @default false
+     */
+    preventAutoFocus?: boolean;
+    /** Reference to the control's API. */
+    apiRef?: React.Ref<TemporalInputController<T, string, React.ComponentRef<typeof DateInput>> | undefined>;
+    /** Properties to pass to the `IssueMessages` component. */
+    issueMessagesProps?: Omit<React.ComponentPropsWithRef<typeof IssueMessages>, "path" | "issues" | "messages" | "unwrapped">;
+}
+/** Date control component supporting nullable temporal schemas. */
+export declare const DateControl: React.ForwardRefExoticComponent<DateControlProps<Temporal | null> & React.RefAttributes<HTMLInputElement>>;

package/dist/types/components/DateControl/index.d.ts

@@ -0,0 +1 @@
+export * from "./DateControl.tsx";

package/dist/types/components/DateRangeControl/DateRangeControl.d.ts

@@ -0,0 +1,79 @@
+import { type Path } from "@ostack.tech/kform";
+import { type Temporal, type TemporalInputController, type TemporalInputOptions } from "@ostack.tech/kform-react";
+import { DateRangeInput } from "@ostack.tech/ui";
+import * as React from "react";
+import { type IssueMessages, type IssueMessagesByCode } from "../IssueMessages";
+/** Properties of the date-range control component. */
+export interface DateRangeControlProps<TStart extends Temporal | null = Temporal | null, TEnd extends Temporal | null = TStart> extends Omit<React.ComponentPropsWithoutRef<typeof DateRangeInput>, "defaultValue" | "value"> {
+    /** Path to the start value. */
+    startPath: string | Path;
+    /** Path to the end value. */
+    endPath: string | Path;
+    /**
+     * Issue messages of this control's start.
+     *
+     * Mapping from an issue's code to its message.
+     */
+    startIssueMessages?: IssueMessagesByCode;
+    /**
+     * Issue messages of this control's end.
+     *
+     * Mapping from an issue's code to its message.
+     */
+    endIssueMessages?: IssueMessagesByCode;
+    /**
+     * Label to use in the issues panel when displaying issues associated with
+     * this field.
+     *
+     * This label has priority over the field's `ControlLabel`.
+     */
+    issuesPanelLabel?: React.ReactNode;
+    /**
+     * Label suffix to use in the issues panel when displaying issues associated
+     * with this field's start date.
+     */
+    issuesPanelStartLabelSuffix?: React.ReactNode;
+    /**
+     * Label suffix to use in the issues panel when displaying issues associated
+     * with this field's end date.
+     */
+    issuesPanelEndLabelSuffix?: React.ReactNode;
+    /**
+     * Whether to display the issues associated with this control.
+     *
+     * @default true
+     */
+    displayIssues?: boolean;
+    /**
+     * Whether to prevent the auto-focusing behaviour that causes this control to
+     * be focused when the form app's `focus` is called with this control's path.
+     *
+     * Preventing this behaviour is useful when multiple controls for the same
+     * path are rendered at once, and only one of them should be focused.
+     *
+     * @default false
+     */
+    preventAutoFocus?: boolean;
+    /** Reference to the start control's API. */
+    startApiRef?: React.Ref<TemporalInputController<TStart, string> | undefined>;
+    /** Reference to the end control's API. */
+    endApiRef?: React.Ref<TemporalInputController<TEnd, string> | undefined>;
+    /** Properties to pass to the `IssueMessages` component. */
+    issueMessagesProps?: Omit<React.ComponentPropsWithRef<typeof IssueMessages>, "path" | "issues" | "messages" | "unwrapped">;
+    onStartInitialized?: TemporalInputOptions<TStart, string>["onInitialized"];
+    onStartFormManagerEvent?: TemporalInputOptions<TStart, string>["onFormManagerEvent"];
+    onStartValueChange?: TemporalInputOptions<TStart, string>["onValueChange"];
+    onStartValidationStatusChange?: TemporalInputOptions<TStart, string>["onValidationStatusChange"];
+    onStartDisplayStatusChange?: TemporalInputOptions<TStart, string>["onDisplayStatusChange"];
+    onStartDirtyStatusChange?: TemporalInputOptions<TStart, string>["onDirtyStatusChange"];
+    onStartTouchedStatusChange?: TemporalInputOptions<TStart, string>["onTouchedStatusChange"];
+    onEndInitialized?: TemporalInputOptions<TEnd, string>["onInitialized"];
+    onEndFormManagerEvent?: TemporalInputOptions<TEnd, string>["onFormManagerEvent"];
+    onEndValueChange?: TemporalInputOptions<TEnd, string>["onValueChange"];
+    onEndValidationStatusChange?: TemporalInputOptions<TEnd, string>["onValidationStatusChange"];
+    onEndDisplayStatusChange?: TemporalInputOptions<TEnd, string>["onDisplayStatusChange"];
+    onEndDirtyStatusChange?: TemporalInputOptions<TEnd, string>["onDirtyStatusChange"];
+    onEndTouchedStatusChange?: TemporalInputOptions<TEnd, string>["onTouchedStatusChange"];
+}
+/** Date-range control component supporting nullable temporal schemas. */
+export declare const DateRangeControl: React.ForwardRefExoticComponent<DateRangeControlProps<Temporal | null, Temporal | null> & React.RefAttributes<HTMLDivElement>>;

package/dist/types/components/DateRangeControl/index.d.ts

@@ -0,0 +1 @@
+export * from "./DateRangeControl.tsx";