@chelone/vue 0.0.0-stage → 0.1.0

package/dist/components/admin/inputs/subscription-plan-picker.vue.js

@@ -0,0 +1,160 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, createTextVNode, toDisplayString, unref, createCommentVNode, createElementVNode, Fragment, renderList, createBlock, withCtx, createVNode } from "vue";
+import { useInput } from "../../../form/use-input.js";
+import { cn } from "../../../lib/utils.js";
+import _sfc_main$1 from "../../ui/button.vue.js";
+import { Card, CardHeader, CardTitle, CardContent } from "../../ui/card.js";
+import { FieldDescription, FieldError } from "../../ui/field.js";
+import _sfc_main$2 from "../common/validation-error.vue.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = ["data-invalid"];
+const _hoisted_2 = {
+  key: 0,
+  class: "text-sm font-medium leading-none"
+};
+const _hoisted_3 = { key: 0 };
+const _hoisted_4 = ["id", "aria-disabled", "aria-invalid"];
+const _hoisted_5 = {
+  key: 0,
+  class: "rounded bg-primary px-2 py-0.5 text-primary-foreground text-xs"
+};
+const _hoisted_6 = { class: "font-semibold text-2xl tabular-nums" };
+const _hoisted_7 = { class: "font-normal text-muted-foreground text-sm" };
+const _hoisted_8 = {
+  key: 0,
+  class: "space-y-1 text-muted-foreground text-sm"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "subscription-plan-picker",
+  props: {
+    source: {},
+    plans: {},
+    recommendedPlanId: {},
+    label: { type: [String, Boolean], default: void 0 },
+    helperText: {},
+    resource: {},
+    validate: {},
+    isRequired: { type: Boolean },
+    defaultValue: {},
+    disabled: { type: Boolean },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { id, value, setValue, error, touched, isRequired } = useInput({
+      source: props.source,
+      validate: props.validate,
+      isRequired: props.isRequired,
+      defaultValue: props.defaultValue
+    });
+    const invalid = computed(() => touched.value && error.value != null);
+    const currentId = computed(
+      () => value.value ?? null
+    );
+    const labelText = computed(
+      () => props.label === false ? null : props.label ?? humanizeSource(props.source)
+    );
+    function formatPrice(plan) {
+      return new Intl.NumberFormat(void 0, {
+        style: "currency",
+        currency: plan.currency
+      }).format(plan.price);
+    }
+    function onSelect(plan) {
+      if (!props.disabled) setValue(plan.id);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("fieldset", {
+        class: normalizeClass([props.class, "flex flex-col gap-3"]),
+        "data-invalid": invalid.value || void 0,
+        "data-slot": "subscription-plan-picker"
+      }, [
+        labelText.value != null ? (openBlock(), createElementBlock("legend", _hoisted_2, [
+          createTextVNode(toDisplayString(labelText.value), 1),
+          unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_3, " *")) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true),
+        createElementVNode("div", {
+          id: unref(id),
+          role: "radiogroup",
+          class: "grid gap-3 sm:grid-cols-3",
+          "aria-disabled": __props.disabled || void 0,
+          "aria-invalid": invalid.value || void 0
+        }, [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.plans, (plan) => {
+            return openBlock(), createBlock(unref(Card), {
+              key: plan.id,
+              "data-plan-card": plan.id,
+              "data-selected": currentId.value === plan.id ? "true" : "false",
+              "data-recommended": __props.recommendedPlanId === plan.id ? "true" : "false",
+              role: "radio",
+              "aria-checked": currentId.value === plan.id,
+              class: normalizeClass(
+                unref(cn)(
+                  "transition",
+                  currentId.value === plan.id && "border-primary ring-2 ring-primary",
+                  __props.recommendedPlanId === plan.id && currentId.value !== plan.id && "border-primary/50"
+                )
+              )
+            }, {
+              default: withCtx(() => [
+                createVNode(unref(CardHeader), null, {
+                  default: withCtx(() => [
+                    createVNode(unref(CardTitle), { class: "flex items-center justify-between" }, {
+                      default: withCtx(() => [
+                        createElementVNode("span", null, toDisplayString(plan.name), 1),
+                        __props.recommendedPlanId === plan.id ? (openBlock(), createElementBlock("span", _hoisted_5, " Recommended ")) : createCommentVNode("", true)
+                      ]),
+                      _: 2
+                    }, 1024),
+                    createElementVNode("div", _hoisted_6, [
+                      createTextVNode(toDisplayString(formatPrice(plan)) + " ", 1),
+                      createElementVNode("span", _hoisted_7, " /" + toDisplayString(plan.interval), 1)
+                    ])
+                  ]),
+                  _: 2
+                }, 1024),
+                createVNode(unref(CardContent), null, {
+                  default: withCtx(() => [
+                    plan.features ? (openBlock(), createElementBlock("ul", _hoisted_8, [
+                      (openBlock(true), createElementBlock(Fragment, null, renderList(plan.features, (feature) => {
+                        return openBlock(), createElementBlock("li", { key: feature }, toDisplayString(feature), 1);
+                      }), 128))
+                    ])) : createCommentVNode("", true),
+                    createVNode(_sfc_main$1, {
+                      type: "button",
+                      class: "mt-4 w-full",
+                      variant: currentId.value === plan.id ? "default" : "outline",
+                      disabled: __props.disabled,
+                      onClick: ($event) => onSelect(plan)
+                    }, {
+                      default: withCtx(() => [
+                        createTextVNode(toDisplayString(currentId.value === plan.id ? "Current" : "Select"), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["variant", "disabled", "onClick"])
+                  ]),
+                  _: 2
+                }, 1024)
+              ]),
+              _: 2
+            }, 1032, ["data-plan-card", "data-selected", "data-recommended", "aria-checked", "class"]);
+          }), 128))
+        ], 8, _hoisted_4),
+        __props.helperText ? (openBlock(), createBlock(unref(FieldDescription), { key: 1 }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(__props.helperText), 1)
+          ]),
+          _: 1
+        })) : createCommentVNode("", true),
+        invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 2 }, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$2, { error: unref(error) }, null, 8, ["error"])
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/subscription-plan-picker2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./subscription-plan-picker.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/text-array-input.vue.d.ts

@@ -0,0 +1,16 @@
+import type { Validator } from "@chelone/core";
+/** Props for {@link TextArrayInput}. */
+export interface TextArrayInputProps {
+    source: string;
+    label?: string | false;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<TextArrayInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TextArrayInputProps> & Readonly<{}>, {
+    label: string | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/inputs/text-array-input.vue.js

@@ -0,0 +1,126 @@
+import { defineComponent, ref, computed, openBlock, createBlock, unref, normalizeClass, withCtx, createTextVNode, toDisplayString, createElementBlock, createCommentVNode, createElementVNode, Fragment, renderList, withModifiers, withDirectives, vModelText, createVNode } from "vue";
+import { useInput } from "../../../form/use-input.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import { Field, FieldLabel, FieldError } from "../../ui/field.js";
+import _sfc_main$1 from "../common/validation-error.vue.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = { class: "group flex flex-wrap gap-1 rounded-md border border-input bg-background px-3 py-1.5 text-sm focus-within:ring-1 focus-within:ring-ring" };
+const _hoisted_3 = ["disabled", "onClick"];
+const _hoisted_4 = { class: "sr-only" };
+const _hoisted_5 = ["id", "aria-invalid", "placeholder", "disabled", "readonly"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "text-array-input",
+  props: {
+    source: {},
+    label: { type: [String, Boolean], default: void 0 },
+    defaultValue: {},
+    validate: {},
+    placeholder: {},
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const emptyArray = [];
+    const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+      source: props.source,
+      defaultValue: props.defaultValue,
+      validate: props.validate,
+      // A nullish stored value renders as an empty tag list, not `''`.
+      format: (raw) => raw ?? emptyArray
+    });
+    const translate = useTranslate();
+    const inputValue = ref("");
+    const values = computed(() => value.value ?? emptyArray);
+    const invalid = computed(() => touched.value && error.value != null);
+    const labelText = computed(
+      () => props.label === false ? null : props.label ?? humanizeSource(props.source)
+    );
+    function addValue(text) {
+      const trimmed = text.trim();
+      if (trimmed) setValue([...values.value, trimmed]);
+      inputValue.value = "";
+    }
+    function removeValue(index) {
+      setValue(values.value.filter((_, i) => i !== index));
+    }
+    function onKeyDown(event) {
+      if (event.key === "Enter") {
+        event.preventDefault();
+        if (inputValue.value.trim()) addValue(inputValue.value);
+      } else if (event.key === "Backspace" && inputValue.value === "" && values.value.length > 0 && !props.readonly) {
+        setValue(values.value.slice(0, -1));
+      }
+    }
+    function onBlur() {
+      if (inputValue.value.trim()) addValue(inputValue.value);
+      blur();
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Field), {
+        class: normalizeClass(props.class),
+        "data-invalid": invalid.value
+      }, {
+        default: withCtx(() => [
+          labelText.value != null ? (openBlock(), createBlock(unref(FieldLabel), {
+            key: 0,
+            "html-for": unref(id)
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(labelText.value), 1),
+              unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["html-for"])) : createCommentVNode("", true),
+          createElementVNode("div", _hoisted_2, [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(values.value, (tag, index) => {
+              return openBlock(), createElementBlock("span", {
+                key: `${tag}-${index}`,
+                class: "inline-flex items-center gap-1 rounded border border-input px-2 py-0.5 text-xs"
+              }, [
+                createTextVNode(toDisplayString(tag) + " ", 1),
+                createElementVNode("button", {
+                  type: "button",
+                  class: "cursor-pointer rounded-full outline-none focus:ring-2 focus:ring-ring",
+                  disabled: __props.disabled || __props.readonly,
+                  onMousedown: _cache[0] || (_cache[0] = withModifiers(() => {
+                  }, ["prevent", "stop"])),
+                  onClick: withModifiers(($event) => removeValue(index), ["prevent"])
+                }, [
+                  createElementVNode("span", _hoisted_4, toDisplayString(unref(translate)("ra.action.remove", { _: "Remove" })), 1),
+                  _cache[2] || (_cache[2] = createElementVNode("span", { "aria-hidden": "true" }, "×", -1))
+                ], 40, _hoisted_3)
+              ]);
+            }), 128)),
+            withDirectives(createElementVNode("input", {
+              id: unref(id),
+              "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => inputValue.value = $event),
+              type: "text",
+              "aria-invalid": invalid.value || void 0,
+              placeholder: values.value.length === 0 ? __props.placeholder : void 0,
+              disabled: __props.disabled,
+              readonly: __props.readonly,
+              class: "ml-1 flex-1 bg-transparent outline-none placeholder:text-muted-foreground",
+              onKeydown: onKeyDown,
+              onBlur
+            }, null, 40, _hoisted_5), [
+              [vModelText, inputValue.value]
+            ])
+          ]),
+          invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+            default: withCtx(() => [
+              createVNode(_sfc_main$1, { error: unref(error) }, null, 8, ["error"])
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["class", "data-invalid"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/text-array-input2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./text-array-input.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/text-input.vue.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `<TextInput>` — single-line text input, the Vue analog of `@chelone/react`'s
+ * `inputs/text-input.tsx`. Binds ONE field via `useInput` (Task 6) and renders
+ * the shadcn `Field` + `Input` primitives. The error is the already-displayable
+ * `string | TranslatableMessage` off `useInput` (rendered through
+ * `<ValidationError>`), never an RHF `error.root.message`.
+ */
+import type { Validator } from "@chelone/core";
+/** Props for {@link TextInput}. */
+export interface TextInputProps {
+    source: string;
+    label?: string | false;
+    type?: string;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    helperText?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    /** Class applied to the inner `<Input>` control (wrappers reserve trailing room). */
+    inputClass?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<TextInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TextInputProps> & Readonly<{}>, {
+    label: string | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/inputs/text-input.vue.js

@@ -0,0 +1,87 @@
+import { defineComponent, computed, openBlock, createBlock, unref, normalizeClass, withCtx, createTextVNode, toDisplayString, createElementBlock, createCommentVNode, createVNode } from "vue";
+import { useInput } from "../../../form/use-input.js";
+import { Field, FieldLabel, FieldError } from "../../ui/field.js";
+import _sfc_main$1 from "../../ui/input.vue.js";
+import _sfc_main$2 from "../common/validation-error.vue.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "text-input",
+  props: {
+    source: {},
+    label: { type: [String, Boolean], default: void 0 },
+    type: {},
+    defaultValue: {},
+    validate: {},
+    helperText: {},
+    placeholder: {},
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    autocomplete: {},
+    autofocus: { type: Boolean },
+    inputClass: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+      source: props.source,
+      defaultValue: props.defaultValue,
+      validate: props.validate,
+      // Coercion papercut fix: core's `defaultParse` maps `""` → `null`, so a
+      // CLEARED required text field would be validated as `null` and a zod
+      // `z.string().min(1)` schema fires its "Expected string, received null" TYPE
+      // error before the friendly `.min(1)` refinement can run. Keep a cleared text
+      // field an empty STRING (identity parse) so the string refinement — and its
+      // custom/i18n message — is what surfaces.
+      parse: (input) => input
+    });
+    const invalid = computed(() => touched.value && error.value != null);
+    const labelText = computed(
+      () => props.label === false ? null : props.label ?? humanizeSource(props.source)
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Field), {
+        class: normalizeClass(props.class),
+        "data-invalid": invalid.value
+      }, {
+        default: withCtx(() => [
+          labelText.value != null ? (openBlock(), createBlock(unref(FieldLabel), {
+            key: 0,
+            "html-for": unref(id)
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(labelText.value), 1),
+              unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["html-for"])) : createCommentVNode("", true),
+          createVNode(_sfc_main$1, {
+            id: unref(id),
+            type: __props.type ?? "text",
+            "model-value": unref(value),
+            placeholder: __props.placeholder,
+            disabled: __props.disabled,
+            readonly: __props.readonly,
+            autocomplete: __props.autocomplete,
+            autofocus: __props.autofocus,
+            "aria-invalid": invalid.value,
+            class: normalizeClass(__props.inputClass),
+            "onUpdate:modelValue": unref(setValue),
+            onBlur: unref(blur)
+          }, null, 8, ["id", "type", "model-value", "placeholder", "disabled", "readonly", "autocomplete", "autofocus", "aria-invalid", "class", "onUpdate:modelValue", "onBlur"]),
+          invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+            default: withCtx(() => [
+              createVNode(_sfc_main$2, { error: unref(error) }, null, 8, ["error"])
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["class", "data-invalid"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/text-input2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./text-input.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/time-input.vue.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `<TimeInput>` — native time picker for a time-of-day value, the Vue analog of
+ * `@chelone/react`'s `inputs/time-input.tsx`. Formats an incoming "HH:mm" string
+ * / `Date` to the display value and — by the default `parse` — stores a `Date`
+ * at today's date with the entered time (pass a custom `parse` to store a raw
+ * string). Empty → `null`, so a required validator fires. Same focused-buffer
+ * pattern as `<DateInput>`.
+ */
+import type { Validator } from "@chelone/core";
+/** Props for {@link TimeInput}. */
+export interface TimeInputProps {
+    source: string;
+    label?: string | false;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    /** Read transform (form value → display string). Default {@link formatTime}. */
+    format?: (value: unknown) => unknown;
+    /** Write transform (display string → stored value). Default {@link parseTimeToDate}. */
+    parse?: (input: unknown) => unknown;
+    helperText?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    inputClass?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<TimeInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TimeInputProps> & Readonly<{}>, {
+    label: string | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/inputs/time-input.vue.js

@@ -0,0 +1,96 @@
+import { defineComponent, computed, ref, watch, openBlock, createBlock, unref, normalizeClass, withCtx, createTextVNode, toDisplayString, createElementBlock, createCommentVNode, createVNode } from "vue";
+import { useInput } from "../../../form/use-input.js";
+import { Field, FieldLabel, FieldError } from "../../ui/field.js";
+import _sfc_main$1 from "../../ui/input.vue.js";
+import _sfc_main$2 from "../common/validation-error.vue.js";
+import { formatTime, parseTimeToDate, isValidTime } from "./date-input-format.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "time-input",
+  props: {
+    source: {},
+    label: { type: [String, Boolean], default: void 0 },
+    defaultValue: {},
+    validate: {},
+    format: {},
+    parse: {},
+    helperText: {},
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    inputClass: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const format = computed(() => props.format ?? formatTime);
+    const parse = computed(() => props.parse ?? parseTimeToDate);
+    const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+      source: props.source,
+      defaultValue: props.defaultValue,
+      validate: props.validate,
+      format: (v) => format.value(v),
+      parse: (v) => parse.value(v)
+    });
+    const buffer = ref(value.value == null ? "" : String(value.value));
+    const focused = ref(false);
+    watch(value, (next) => {
+      if (!focused.value) buffer.value = next == null ? "" : String(next);
+    });
+    const invalid = computed(() => touched.value && error.value != null);
+    const labelText = computed(
+      () => props.label === false ? null : props.label ?? humanizeSource(props.source)
+    );
+    function onInput(raw) {
+      buffer.value = raw;
+      if (raw !== "" && isValidTime(raw)) setValue(raw);
+    }
+    function onBlur() {
+      focused.value = false;
+      if (isValidTime(buffer.value)) setValue(buffer.value);
+      blur();
+      buffer.value = value.value == null ? "" : String(value.value);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Field), {
+        class: normalizeClass(props.class),
+        "data-invalid": invalid.value
+      }, {
+        default: withCtx(() => [
+          labelText.value != null ? (openBlock(), createBlock(unref(FieldLabel), {
+            key: 0,
+            "html-for": unref(id)
+          }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(labelText.value), 1),
+              unref(isRequired) ? (openBlock(), createElementBlock("span", _hoisted_1, " *")) : createCommentVNode("", true)
+            ]),
+            _: 1
+          }, 8, ["html-for"])) : createCommentVNode("", true),
+          createVNode(_sfc_main$1, {
+            id: unref(id),
+            type: "time",
+            "model-value": buffer.value,
+            disabled: __props.disabled,
+            readonly: __props.readonly,
+            "aria-invalid": invalid.value,
+            class: normalizeClass(__props.inputClass),
+            onFocus: _cache[0] || (_cache[0] = ($event) => focused.value = true),
+            "onUpdate:modelValue": onInput,
+            onBlur
+          }, null, 8, ["id", "model-value", "disabled", "readonly", "aria-invalid", "class"]),
+          invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+            default: withCtx(() => [
+              createVNode(_sfc_main$2, { error: unref(error) }, null, 8, ["error"])
+            ]),
+            _: 1
+          })) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["class", "data-invalid"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/time-input2.vue.js

@@ -0,0 +1,4 @@
+import _sfc_main from "./time-input.vue.js";
+export {
+  _sfc_main as default
+};

package/dist/components/admin/inputs/use-choice-input.d.ts

@@ -0,0 +1,73 @@
+/**
+ * `useChoiceInput` — the shared setup the six choice inputs (select /
+ * select-array / autocomplete / autocomplete-array / checkbox-group /
+ * radio-button-group) run before they diverge on presentation. It folds the
+ * three moves every twin makes at the top of its body into one call:
+ *
+ *  1. resolve the choices context (`useChoicesContext`, props-over-context —
+ *     inline `choices` win, else the ambient reference context), throwing the
+ *     twin's "you must provide the source prop" error when neither yields a
+ *     `source`;
+ *  2. wire the choice accessors (`useChoices`) with the twin's reference-aware
+ *     `optionText` / `translateChoice` defaults;
+ *  3. expose the context's data fields as REACTIVE computeds.
+ *
+ * Idiom note (why computeds, not a destructure): a reference context
+ * ({@link useReferenceInput}) carries its data through GETTERS over the
+ * controller store. Destructuring `allChoices`/`isPending`/`error` would read a
+ * getter once and freeze it; wrapping each in a `computed` re-reads the getter
+ * inside a tracking scope, so the list stays live as the controller settles —
+ * the Vue analog of the React twin re-deriving the object each render. `source`
+ * / `resource` / `isFromReference` are stable per context, so they are read once
+ * (parity with the twin's `useState` capture of the reference options).
+ */
+import { type ComputedRef } from "vue";
+import { type ChoiceRecord, type OptionText } from "../../../choices/use-choices.js";
+/** Options for {@link useChoiceInput}. */
+export interface UseChoiceInputOptions {
+    /** Component name used in the "must provide the source prop" error. */
+    componentName: string;
+    /** Inline choices — synthesized into a static context, ignoring any ambient one. */
+    choices?: readonly (string | ChoiceRecord)[];
+    /** The FK/field path (falls back to the ambient reference context's source). */
+    source?: string;
+    /** The display path or a formatter. */
+    optionText?: OptionText;
+    /** The value path. Default `id` (via `useChoices`). */
+    optionValue?: string;
+    /** The disabled-flag path. Default `disabled`. */
+    disableValue?: string;
+    /** Translate a string-path label. Default `!isFromReference`. */
+    translateChoice?: boolean;
+    /**
+     * The `optionText` fallback for a NON-reference context when `optionText` is
+     * omitted (a reference context always falls back to the record
+     * representation). `undefined` lets `useChoices` apply its own `name` default;
+     * the autocomplete twins pass `"name"` explicitly.
+     */
+    defaultOptionText?: OptionText;
+}
+/** The resolved choice-input surface — accessors + reactive context fields. */
+export interface UseChoiceInputResult {
+    /** The resolved `source` (guaranteed defined — the composable throws otherwise). */
+    source: string;
+    /** `true` for a reference context, `false` for inline choices. */
+    isFromReference: boolean;
+    /** The referenced resource name (inline: `undefined`). */
+    resource: string | undefined;
+    /** The full choice list (reactive). */
+    allChoices: ComputedRef<ChoiceRecord[]>;
+    /** Whether the reference list is still loading (inline: `false`). */
+    isPending: ComputedRef<boolean>;
+    /** The reference fetch error (inline: `null`). */
+    fetchError: ComputedRef<unknown>;
+    /** The display text for a choice. */
+    getChoiceText(choice: ChoiceRecord): string;
+    /** The value for a choice (`optionValue` path or `id`). */
+    getChoiceValue(choice: ChoiceRecord): unknown;
+    /** The disabled flag for a choice. */
+    getDisableValue(choice: ChoiceRecord): unknown;
+    /** Push a filter onto a reference context (inert for inline choices). */
+    setFilters(filter: Record<string, unknown>, debounce?: boolean): void;
+}
+export declare function useChoiceInput(options: UseChoiceInputOptions): UseChoiceInputResult;