ropav 0.2.0 → 0.3.0

package/dist/utils/componentColors.d.ts

@@ -1,78 +0,0 @@
-export declare const componentColors: readonly ["primary", "gray", "red", "pink", "grape", "violet", "indigo", "blue", "cyan", "teal", "green", "lime", "yellow", "orange"];
-export declare const componentColorShades: readonly ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
-export type ComponentColor = (typeof componentColors)[number];
-export type ComponentColorShade = (typeof componentColorShades)[number];
-export type ComponentColorShadeValue = `${ComponentColor}.${ComponentColorShade}`;
-export type ComponentColorValue = ComponentColor | ComponentColorShadeValue | (string & {});
-export type ComponentColorVariant = 'solid' | 'subtle' | 'surface' | 'outline' | 'ghost' | 'plain';
-export interface ComponentColorRoles {
-    filled: string;
-    hover: string;
-    active: string;
-    contrast: string;
-    contrastHover: string;
-    contrastActive: string;
-    light: string;
-    lightHover: string;
-    lightActive: string;
-    outline: string;
-    outlineHover: string;
-    foreground: string;
-}
-export interface ComponentVariantColorRoles {
-    background: string;
-    hover: string;
-    active: string;
-    color: string;
-    colorHover: string;
-    colorActive: string;
-    border: string;
-    borderHover: string;
-    borderActive: string;
-}
-export interface ComponentContrastColorOptions {
-    /** Automatically selects a readable foreground for preset and opaque custom colors. */
-    autoContrast?: boolean;
-    /** Required when an automatically contrasted custom color is translucent. */
-    contrastColor?: string;
-}
-export interface ComponentContrastColorRoles {
-    color: string;
-    hover: string;
-    active: string;
-}
-export interface ComponentVariantColorOptions extends ComponentContrastColorOptions {
-    color: ComponentColorValue | undefined;
-    variant: ComponentColorVariant | undefined;
-    defaultColor?: ComponentColorValue;
-}
-export interface ComponentCheckedColorStyleOptions extends ComponentContrastColorOptions {
-    color: ComponentColorValue | undefined;
-    colorProperty: `--${string}`;
-    checkedColorProperty: `--${string}`;
-    defaultColor?: ComponentColorValue;
-}
-export type ParsedComponentColor = {
-    kind: 'empty';
-} | {
-    kind: 'preset';
-    color: ComponentColor;
-} | {
-    kind: 'shade';
-    color: ComponentColor;
-    shade: ComponentColorShade;
-} | {
-    kind: 'custom';
-    value: string;
-} | {
-    kind: 'invalid';
-    value: string;
-};
-export declare function isComponentPresetColor(color: ComponentColorValue | undefined): color is ComponentColor;
-export declare function parseComponentColor(color: ComponentColorValue | undefined): ParsedComponentColor;
-export declare function getComponentColorValue(color: ComponentColorValue | undefined): string | undefined;
-export declare function getComponentContrastColor(color: ComponentColorValue | undefined, options?: ComponentContrastColorOptions): string;
-export declare function getComponentCheckedColorStyle({ color, colorProperty, checkedColorProperty, defaultColor, autoContrast, contrastColor, }: ComponentCheckedColorStyleOptions): Record<string, string> | undefined;
-export declare function getComponentContrastColorRoles(color: ComponentColorValue | undefined, options?: ComponentContrastColorOptions): ComponentContrastColorRoles;
-export declare function getComponentColorRoles(color: ComponentColorValue | undefined): ComponentColorRoles | undefined;
-export declare function getComponentVariantColorRoles({ color, variant, defaultColor, autoContrast, contrastColor, }: ComponentVariantColorOptions): ComponentVariantColorRoles | undefined;

package/dist/utils/date.d.ts

@@ -1,13 +0,0 @@
-export declare function isValidDate(value: unknown): value is Date;
-export declare function toLocalDate(value: Date): Date;
-export declare function normalizeDate(value: Date | null | undefined): Date | null;
-export declare function toDateKey(value: Date): string;
-export declare function parseDateKey(value: string): Date | null;
-export declare function compareDates(left: Date, right: Date): number;
-export declare function isSameDate(left: Date | null | undefined, right: Date | null | undefined): boolean;
-export declare function isSameMonth(left: Date, right: Date): boolean;
-export declare function startOfMonth(value: Date): Date;
-export declare function endOfMonth(value: Date): Date;
-export declare function addCalendarDays(value: Date, amount: number): Date;
-export declare function addCalendarMonths(value: Date, amount: number): Date;
-export declare function addCalendarYears(value: Date, amount: number): Date;

package/dist/utils/dateAvailability.d.ts

@@ -1,7 +0,0 @@
-export type DisabledDateRule = readonly Date[] | ((date: Date) => boolean);
-export interface DateAvailabilityOptions {
-    min?: Date;
-    max?: Date;
-    disabledDates?: DisabledDateRule;
-}
-export declare function isDateUnavailable(date: Date, options: DateAvailabilityOptions): boolean;

package/dist/utils/dom/ancestry.d.ts

@@ -1,8 +0,0 @@
-export interface ObserveComposedAncestryOptions {
-    deferWhileDisconnected?: boolean;
-    notifyOnDisconnect?: boolean;
-}
-export declare function getComposedParent(node: Node): Node | null;
-export declare function getComposedAncestry(node: Node | null | undefined): Node[];
-export declare function areNodeListsIdentical(left: readonly Node[], right: readonly Node[]): boolean;
-export declare function observeComposedAncestry(getNodes: () => readonly (Node | null | undefined)[], onChange: () => void, options?: ObserveComposedAncestryOptions): () => void;

package/dist/utils/dom/attributes.d.ts

@@ -1,16 +0,0 @@
-export type AttributeSnapshot<Name extends string = string> = ReadonlyMap<Name, string | null>;
-export interface CompatibilityAttributes {
-    class?: unknown;
-    style?: unknown;
-}
-export type EventHandler<EventType extends Event> = (event: EventType) => unknown;
-export declare function splitCompatibilityAttributes<Attributes extends CompatibilityAttributes>(attributes: Attributes): {
-    compatibilityClass: Attributes['class'];
-    compatibilityStyle: Attributes['style'];
-    forwardedAttributes: Omit<Attributes, 'class' | 'style'>;
-};
-export declare function composeEventHandlers<EventType extends Event>(...handlers: ReadonlyArray<EventHandler<EventType> | undefined>): (event: EventType) => void;
-export declare function parseAttributeTokens(value: string | null | undefined): string[];
-export declare function hasAttributeToken(value: string | null | undefined, token: string): boolean;
-export declare function snapshotAttributes<Name extends string>(element: Element, attributes: readonly Name[]): AttributeSnapshot<Name>;
-export declare function restoreAttributes(element: Element, snapshot: AttributeSnapshot): void;

package/dist/utils/dom/componentRef.d.ts

@@ -1,4 +0,0 @@
-import { ComponentPublicInstance, VaporComponentInstance } from 'vue';
-export type ComponentElementRef = Element | ComponentPublicInstance | VaporComponentInstance | null;
-export declare function toHTMLElement(value: ComponentElementRef, fallbackId?: string): HTMLElement | null;
-export declare function resolveHTMLElementRef(value: ComponentElementRef, fallbackId: string, resolve: (element: HTMLElement | null) => void): void;

package/dist/utils/dom/direction.d.ts

@@ -1,2 +0,0 @@
-export type ElementDirection = 'ltr' | 'rtl';
-export declare function getElementDirection(element: Element): ElementDirection;

package/dist/utils/dom/events.d.ts

@@ -1,5 +0,0 @@
-export declare function isNodeWithinElement(value: unknown, element: unknown): value is Node;
-export declare function isEventWithinElement(event: Event, element: Element): boolean;
-export type EventContainmentTarget = string | Element | null | undefined;
-export declare function isEventWithinTargets(event: Event, targets: readonly EventContainmentTarget[]): boolean;
-export declare function createCancelableCustomEvent<T>(type: string, detail: T, originalEvent: Event): CustomEvent<T>;

package/dist/utils/dom/files.d.ts

@@ -1,3 +0,0 @@
-export declare function normalizeSelectedFiles(files: Iterable<File>, multiple: boolean): File[];
-export declare function haveSameFiles(fileList: FileList | null, files: readonly File[]): boolean;
-export declare function replaceInputFiles(input: HTMLInputElement, files: readonly File[]): boolean;

package/dist/utils/dom/focusNavigation.d.ts

@@ -1,10 +0,0 @@
-export type FocusNavigationOrientation = 'horizontal' | 'vertical';
-export interface FocusNavigationCollectionOptions {
-    itemSelector: string;
-    collectionSelector: string;
-}
-export interface FocusNavigationOptions extends FocusNavigationCollectionOptions {
-    orientation: FocusNavigationOrientation;
-}
-export declare function setFocusNavigationTabStop<ElementType extends HTMLElement>(collection: HTMLElement, preferredItem: ElementType | null, options: FocusNavigationCollectionOptions): ElementType | null;
-export declare function getFocusNavigationTarget<ElementType extends HTMLElement>(event: Pick<KeyboardEvent, 'key' | 'target'>, collection: HTMLElement, options: FocusNavigationOptions): ElementType | undefined;

package/dist/utils/dom/interactive.d.ts

@@ -1,2 +0,0 @@
-export declare const INTERACTIVE_ELEMENT_SELECTOR: string;
-export declare function isInteractiveElement(target: unknown, ignoredSelector?: string): boolean;

package/dist/utils/dom/nativeChoice.d.ts

@@ -1,17 +0,0 @@
-export interface NativeChoiceOption<Value> {
-    value: Value;
-}
-export interface NativeSelectChoiceAdapter<Value> {
-    commit: (select: HTMLSelectElement, value: Value, defaultValue: Value, applyValue: () => void) => void;
-    read: (select: HTMLSelectElement) => Value;
-    resolveResetValue: (select: HTMLSelectElement, initialValue: Value) => Value;
-    sync: (select: HTMLSelectElement, value: Value, defaultValue: Value) => void;
-}
-interface SingleNativeChoiceAdapterOptions<Value> {
-    emptyValue: Value;
-    options: () => readonly NativeChoiceOption<Value>[] | undefined;
-}
-export declare function createSingleNativeChoiceAdapter<Value>(options: SingleNativeChoiceAdapterOptions<Value>): NativeSelectChoiceAdapter<Value>;
-export declare function createMultipleNativeChoiceAdapter<Value>(options: () => readonly NativeChoiceOption<Value>[] | undefined): NativeSelectChoiceAdapter<Value[]>;
-export declare function createStringListNativeChoiceAdapter(): NativeSelectChoiceAdapter<string[]>;
-export {};

package/dist/utils/dom/pointerSession.d.ts

@@ -1,20 +0,0 @@
-type PointerSessionEndUpdate = 'event' | 'none' | 'pending-pointerup';
-type PointerSessionUpdateMode = 'animation-frame' | 'immediate';
-interface PointerSessionAdapter<TState> {
-    endUpdate?: PointerSessionEndUpdate;
-    onStart?: (event: PointerEvent, state: TState) => void;
-    onStop?: (state: TState) => void;
-    onUpdate: (event: PointerEvent, state: TState) => void;
-    refreshGeometry?: (state: TState) => boolean;
-    updateMode?: PointerSessionUpdateMode;
-}
-interface PointerSessionStart<TState> {
-    geometryDirty?: boolean;
-    state: TState;
-    target: HTMLElement;
-}
-export declare function createPointerSession<TState>(adapter: PointerSessionAdapter<TState>): {
-    start: (event: PointerEvent, initialize: () => PointerSessionStart<TState> | undefined) => boolean;
-    stop: () => void;
-};
-export {};

package/dist/utils/dom/query.d.ts

@@ -1,4 +0,0 @@
-export declare function isElement(value: unknown): value is Element;
-export declare function matchesSelectorSafe(element: Element, selector: string): boolean;
-export declare function querySelectorSafe<ElementType extends Element = Element>(selector: string, root?: ParentNode | null): ElementType | null;
-export declare function querySelectorAllSafe<ElementType extends Element = Element>(selector: string, root?: ParentNode | null): ElementType[];

package/dist/utils/dom/scroll.d.ts

@@ -1,24 +0,0 @@
-import { ElementDirection } from './direction.js';
-export type ScrollAxis = 'x' | 'y';
-export type ScrollDirection = ElementDirection;
-export interface KeyboardScrollPositionOptions {
-    axis: ScrollAxis;
-    key: string;
-    current: number;
-    pageSize: number;
-    maxPosition: number;
-    direction: ScrollDirection;
-    lineStep: number;
-}
-export declare function getScrollDirection(element: Element): ScrollDirection;
-export declare function getLogicalHorizontalScrollPosition(scrollLeft: number, maxPosition: number, direction: ScrollDirection): number;
-export declare function getRawHorizontalScrollPosition(position: number, maxPosition: number, direction: ScrollDirection): number;
-export declare function getScrollThumbGeometry(trackSize: number, viewportSize: number, scrollSize: number, minimumSize: number): {
-    size: number;
-    offsetRatio: number;
-};
-export declare function getScrollThumbOffset(position: number, maxPosition: number, sizeRatio: number): number;
-export declare function getKeyboardScrollPosition({ axis, key, current, pageSize, maxPosition, direction, lineStep, }: KeyboardScrollPositionOptions): number | undefined;
-export declare function getWheelScrollDelta(axis: ScrollAxis, event: Pick<WheelEvent, 'deltaX' | 'deltaY'>, direction: ScrollDirection): number;
-export declare function applyFallbackScrollPosition(element: Pick<HTMLElement, 'scrollLeft' | 'scrollTop'>, options: Pick<ScrollToOptions, 'left' | 'top'>, mode: 'absolute' | 'relative'): void;
-export declare function getPointerAxisCoordinate(axis: ScrollAxis, event: Pick<PointerEvent, 'clientX' | 'clientY'>): number;

package/dist/utils/floatingOffset.d.ts

@@ -1,10 +0,0 @@
-export interface FloatingOffsetAxes {
-    mainAxis?: number;
-    crossAxis?: number;
-}
-export type FloatingOffsetValue = number | FloatingOffsetAxes;
-export interface FloatingOffsetProperties {
-    mainAxis: `--${string}`;
-    crossAxis: `--${string}`;
-}
-export declare function getFloatingOffsetStyle(offset: FloatingOffsetValue | null | undefined, properties: FloatingOffsetProperties): Record<string, string> | undefined;

package/dist/utils/geometry.d.ts

@@ -1,14 +0,0 @@
-export interface Point {
-    x: number;
-    y: number;
-}
-export type Triangle = [Point, Point, Point];
-type RectBounds = Pick<DOMRect, 'bottom' | 'height' | 'left' | 'right' | 'top' | 'width'>;
-export declare function getClientPoint(event: Pick<MouseEvent, 'clientX' | 'clientY'>): Point;
-export declare function hasMeasuredRect(rect: Pick<DOMRect, 'height' | 'width'>): boolean;
-export declare function isPointInRect(point: Point, rect: RectBounds, padding?: number): boolean;
-export declare function getTriangleArea(a: Point, b: Point, c: Point): number;
-export declare function isPointInTriangle(point: Point, triangle: Triangle, tolerance?: number): boolean;
-export declare function clampPointToRect(point: Point, rect: RectBounds): Point;
-export declare function createPointRect(point: Point): DOMRect;
-export {};

package/dist/utils/indexPath.d.ts

@@ -1,6 +0,0 @@
-export type IndexPath = number[];
-export declare function getPathKey(path: IndexPath): string;
-export declare function getParentPath(path: IndexPath): IndexPath;
-export declare function arePathsEqual(a: IndexPath, b: IndexPath): boolean;
-export declare function isPathPrefix(prefix: IndexPath, path: IndexPath): boolean;
-export declare function normalizePath(indexOrPath: number | IndexPath): IndexPath;

package/dist/utils/optionFilter.d.ts

@@ -1,5 +0,0 @@
-export interface LabeledOption {
-    label: string;
-}
-export type OptionFilter<Option> = (option: Option, searchValue: string) => boolean;
-export declare function filterOptions<Option extends LabeledOption>(options: readonly Option[] | undefined, searchValue: string, filter: OptionFilter<Option> | false | undefined): Option[];

package/dist/utils/rafScheduler.d.ts

@@ -1,4 +0,0 @@
-export declare function createRafScheduler(callback: () => void, getView: () => Window | null | undefined): {
-    cancel: () => void;
-    schedule: () => void;
-};

package/dist/utils/text.d.ts

@@ -1,2 +0,0 @@
-export declare function getNameInitials(name: string | null | undefined): string;
-export declare function normalizeTypeaheadText(value: string, locales?: Intl.LocalesArgument): string;

package/dist/x.js

@@ -1,12 +0,0 @@
-import { defineVaporComponent, markRaw, template } from "vue";
-//#region ~icons/lucide/x
-var t0 = template("<svg viewBox=\"0 0 24 24\"width=1.2em height=1.2em><path fill=none stroke=currentColor stroke-linecap=round stroke-linejoin=round stroke-width=2 d=\"M18 6L6 18M6 6l12 12\">", 3, 1);
-function render(_ctx) {
-	return t0();
-}
-var x_default = markRaw(defineVaporComponent({
-	name: "lucide-x",
-	render
-}));
-//#endregion
-export { x_default as t };

package/docs/code-architecture.md

@@ -1,147 +0,0 @@
-# Code architecture
-
-This guide defines the source structure expected from contributors. The goal is a predictable
-codebase where UI files describe rendering, behavior is testable through small interfaces, and
-shared logic has one obvious home.
-
-## Package seams
-
-This repository publishes `ropav`, a zero-VDOM UI component library for Vue Vapor. Paths such as
-`src/utils/` below are relative to this package's root.
-
-The library integrates `@floating-ui/dom` and `focus-trap` through package dependencies, and it
-exposes public composables, component subpath exports, design tokens, and styles through its
-`package.json` exports. Production source stays zero-VDOM: component rendering, style injection,
-and accessible behavior are built with Vue Vapor, never through VDOM interfaces.
-
-## Module seams
-
-A module should hide a meaningful amount of behavior behind a small interface. Extract code around
-a responsibility, not merely to reduce a line count. A useful extraction makes callers simpler and
-lets tests exercise the same interface that production code uses.
-
-Use this dependency direction:
-
-```text
-Vue components and component-local modules
-    -> internal composables
-    -> public composables
-    -> utilities
-```
-
-A higher layer may also import a lower layer directly. Lower layers must not import higher layers:
-
-- `src/utils/` does not import components or composables.
-- `src/composables/` does not import components or internal modules.
-- `src/internal/` does not import components.
-- Components may compose other components when the dependency remains acyclic.
-
-## Where code belongs
-
-| Location                                  | Responsibility                                                        |
-| ----------------------------------------- | --------------------------------------------------------------------- |
-| `src/components/<name>/*.vue`             | Template, bindings, slots, and lightweight view-derived state         |
-| `src/components/<name>/useX.ts`           | Component-specific reactive state, lifecycle, and event orchestration |
-| `src/components/<name>/<concern>Model.ts` | Pure behavior that encodes only that component's contract             |
-| `src/internal/composables/`               | Shared reactive behavior that is not part of the package interface    |
-| `src/composables/`                        | Reusable public composables exported by the package                   |
-| `src/utils/`                              | Reusable runtime helpers without component state or lifecycle         |
-| `src/utils/dom/`                          | Reusable helpers that operate on browser and DOM primitives           |
-| `tests/`, `tooling/`, `scripts/`          | Test, build, and repository automation helpers                        |
-
-Do not add catch-all `utils`, `helpers`, or `core` modules beside a component. Keep a pure helper
-local when it expresses one component's contract, and give it a semantic name such as
-`sliderModel`. Move it to `src/utils/` once more than one feature needs the behavior.
-
-## Component shape
-
-Production SFCs use `<script setup lang="ts" vapor>` and remain zero-VDOM. Do not use `h`, `VNode`,
-`defineComponent`, `createVNode`, or related VDOM block helpers in production source.
-
-Keep SFC blocks in this order:
-
-1. `<template>`
-2. `<script setup lang="ts" vapor>`
-3. `<style>`
-
-Within the script block, use this order:
-
-1. Imports
-2. `defineOptions`, props defaults, emits, and slots
-3. Composable state and template refs
-4. View-derived computed attributes
-5. Small event adapters and `defineExpose`
-
-A short computed value used only to bind the template can stay in the SFC. Move state transitions,
-timers, document listeners, multi-step event handling, and reusable calculations behind a
-composable or pure model interface.
-
-## Function design
-
-Oxlint enforces a conservative baseline of cyclomatic complexity 20, nesting depth 4, at most 5
-parameters, and at most 250 non-blank, non-comment lines per function. These are upper bounds, not
-targets.
-
-- Give each function one reason to change.
-- Prefer guard clauses over deeply nested branches.
-- Use an options object when several parameters describe one concept.
-- Split orchestration into named steps, while keeping the external interface small.
-- Accept dependencies or callbacks at the module seam instead of constructing hard-to-test global
-  dependencies inside the implementation.
-- Return observable results where practical; isolate side effects in lifecycle or event adapters.
-
-Do not create shallow pass-through functions solely to satisfy a metric. A refactor should improve
-the caller, the module interface, or the test surface.
-
-## Imports and package interfaces
-
-- Import utilities directly from their module, for example `@/utils/number`; do not add a utils
-  barrel.
-- Component `index.ts` files define package-facing exports. Internal code should not import from the
-  root package barrel.
-- Keep imports acyclic. If two modules need each other, move the shared behavior to the lowest
-  layer that owns the concept.
-- Use `import type` for type-only dependencies.
-
-## Testing
-
-Test through the interface of the extracted module:
-
-- Pure models and utilities use deterministic unit tests.
-- Composables test returned state and commands, using the smallest host needed for lifecycle
-  behavior.
-- Component tests cover DOM integration, events, accessibility, and public rendering contracts.
-- Storybook tests cover visual and interaction scenarios that depend on real browser layout.
-
-Tests should assert observable behavior rather than private implementation details. Refactoring a
-module internally should not require rewriting its behavioral tests.
-
-### Storybook organization
-
-Keep component stories beside their component at
-`src/components/<name>/<name>.stories.ts`. Use human-readable Storybook titles with this hierarchy:
-
-```text
-Foundations/<name>
-Components/<category>/<name>
-Utilities/<name>
-Contracts/<name>
-```
-
-Component categories are `Actions`, `Data Display`, `Feedback`, `Forms`, `Layout`, `Navigation`,
-and `Overlays`. Foundations document design tokens, utilities demonstrate lower-level package
-capabilities, and contracts exercise cross-component or browser integration behavior.
-
-## Contributor checklist
-
-Before opening a pull request:
-
-- The SFC primarily adapts props, slots, and composable results to the template.
-- New reusable helpers live in `src/utils/`; feature-only pure logic has a semantic local name.
-- Dependency direction remains downward and acyclic.
-- Functions stay below the enforced complexity, depth, length, and parameter limits.
-- New behavior is tested at the module interface.
-- The package defines a `verify` script for package-owned type, test, build, and bundle behavior.
-- Lint, formatting, architecture, and zero-VDOM bundle contracts run from the root verification
-  interface.
-- `pnpm verify` passes from the repository root.

package/docs/public-composables-api.md

@@ -1,52 +0,0 @@
-# Public composables API
-
-Ropav exposes framework-level composables from both the root package and the dedicated
-`ropav/composables` entrypoint. Prefer the dedicated entrypoint when an application only needs
-headless state behavior.
-
-## `useControllableValue`
-
-`useControllableValue` implements the controlled/uncontrolled value pattern used across Ropav
-components and composables. A defined `modelValue` makes the value controlled; only `undefined`
-selects internal state, so values such as `null` and `false` remain controlled values.
-
-```vue
-<script setup lang="ts">
-import { useControllableValue } from 'ropav/composables';
-
-const props = withDefaults(
-  defineProps<{
-    modelValue?: string;
-    defaultValue?: string;
-  }>(),
-  {
-    modelValue: undefined,
-    defaultValue: '',
-  },
-);
-
-const emit = defineEmits<{
-  'update:modelValue': [value: string];
-}>();
-
-const { value, isControlled, setValue, resetValue } = useControllableValue({
-  modelValue: () => props.modelValue,
-  defaultValue: () => props.defaultValue,
-  onChange: (value) => emit('update:modelValue', value),
-});
-</script>
-```
-
-`defaultValue()` is read once when the composable is created. `setValue()` updates internal state
-only in uncontrolled mode and always calls `onChange`, including repeated requests for the same
-value. In controlled mode, the parent remains responsible for updating `modelValue`, and a rejected
-change request does not replace the internal fallback.
-
-`resetValue(value)` updates uncontrolled state without calling `onChange`. Calling `resetValue()`
-without an argument restores the initial default. A reset is a no-op while controlled. If a value
-changes from controlled to uncontrolled, the latest defined controlled value becomes the internal
-fallback synchronously. Releasing control does not call `onChange`.
-
-The return value contains readonly `value` and `isControlled` computed refs, the captured
-`initialValue`, and the `setValue()` and `resetValue()` commands. `undefined` is reserved as the
-uncontrolled sentinel and should not be used as a controlled value.