@chelone/vue 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,157 @@
+import { defineComponent, computed, openBlock, createElementBlock, normalizeClass, createVNode, unref, withCtx, createTextVNode, toDisplayString, Fragment, renderList, createBlock, createCommentVNode } from "vue";
+import { useInput } from "../../../form/use-input.js";
+import { useTranslate } from "../../../i18n/use-translate.js";
+import _sfc_main$1 from "../../ui/checkbox.vue.js";
+import { FieldDescription, FieldError } from "../../ui/field.js";
+import { Table, TableHeader, TableRow, TableHead, TableBody, TableCell } from "../../ui/table.js";
+import _sfc_main$2 from "../common/validation-error.vue.js";
+import { useChoiceInput } from "./use-choice-input.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "datagrid-input",
+  props: {
+    optionLabel: {},
+    source: {},
+    choices: {},
+    optionText: {},
+    optionValue: { default: "id" },
+    disableValue: {},
+    translateChoice: { type: Boolean },
+    label: { type: [String, Boolean] },
+    helperText: {},
+    defaultValue: {},
+    validate: {},
+    disabled: { type: Boolean },
+    readonly: { type: Boolean },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const translate = useTranslate();
+    const emptyArray = [];
+    const { source, allChoices, getChoiceText, getChoiceValue } = useChoiceInput({
+      componentName: "DatagridInput",
+      choices: props.choices,
+      source: props.source,
+      optionText: props.optionText ?? "name",
+      optionValue: props.optionValue,
+      disableValue: props.disableValue,
+      translateChoice: props.translateChoice
+    });
+    const { id, value, setValue, blur, error, touched } = useInput({
+      source,
+      defaultValue: props.defaultValue,
+      validate: props.validate,
+      format: (raw) => Array.isArray(raw) ? raw : emptyArray
+    });
+    const invalid = computed(() => touched.value && error.value != null);
+    const selectedIds = computed(
+      () => Array.isArray(value.value) ? value.value : emptyArray
+    );
+    const allIds = computed(
+      () => allChoices.value.map((choice) => getChoiceValue(choice))
+    );
+    const allSelected = computed(
+      () => allIds.value.length > 0 && allIds.value.every((rowId) => isSelected(rowId))
+    );
+    const helper = computed(() => props.helperText);
+    function isSelected(rowId) {
+      return selectedIds.value.some((v) => String(v) === String(rowId));
+    }
+    function toggle(rowId) {
+      setValue(
+        isSelected(rowId) ? selectedIds.value.filter((v) => String(v) !== String(rowId)) : [...selectedIds.value, rowId]
+      );
+      blur();
+    }
+    function toggleAll() {
+      setValue(allSelected.value ? [] : allIds.value);
+      blur();
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(props.class),
+        "data-slot": "datagrid-input"
+      }, [
+        createVNode(unref(Table), null, {
+          default: withCtx(() => [
+            createVNode(unref(TableHeader), null, {
+              default: withCtx(() => [
+                createVNode(unref(TableRow), null, {
+                  default: withCtx(() => [
+                    createVNode(unref(TableHead), { class: "w-10" }, {
+                      default: withCtx(() => [
+                        createVNode(_sfc_main$1, {
+                          "model-value": allSelected.value,
+                          "aria-label": unref(translate)("ra.action.select_all", { _: "Select all" }),
+                          "aria-invalid": invalid.value || void 0,
+                          "onUpdate:modelValue": toggleAll
+                        }, null, 8, ["model-value", "aria-label", "aria-invalid"])
+                      ]),
+                      _: 1
+                    }),
+                    createVNode(unref(TableHead), null, {
+                      default: withCtx(() => [
+                        createTextVNode(toDisplayString(__props.optionLabel), 1)
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  _: 1
+                })
+              ]),
+              _: 1
+            }),
+            createVNode(unref(TableBody), null, {
+              default: withCtx(() => [
+                (openBlock(true), createElementBlock(Fragment, null, renderList(unref(allChoices), (choice) => {
+                  return openBlock(), createBlock(unref(TableRow), {
+                    key: String(unref(getChoiceValue)(choice)),
+                    "data-state": isSelected(unref(getChoiceValue)(choice)) ? "selected" : void 0
+                  }, {
+                    default: withCtx(() => [
+                      createVNode(unref(TableCell), null, {
+                        default: withCtx(() => [
+                          createVNode(_sfc_main$1, {
+                            id: `${unref(id)}-${String(unref(getChoiceValue)(choice))}`,
+                            "model-value": isSelected(unref(getChoiceValue)(choice)),
+                            "aria-label": unref(translate)("ra.action.select_row", { _: "Select this row" }),
+                            "onUpdate:modelValue": ($event) => toggle(unref(getChoiceValue)(choice))
+                          }, null, 8, ["id", "model-value", "aria-label", "onUpdate:modelValue"])
+                        ]),
+                        _: 2
+                      }, 1024),
+                      createVNode(unref(TableCell), null, {
+                        default: withCtx(() => [
+                          createTextVNode(toDisplayString(unref(getChoiceText)(choice)), 1)
+                        ]),
+                        _: 2
+                      }, 1024)
+                    ]),
+                    _: 2
+                  }, 1032, ["data-state"]);
+                }), 128))
+              ]),
+              _: 1
+            })
+          ]),
+          _: 1
+        }),
+        helper.value ? (openBlock(), createBlock(unref(FieldDescription), { key: 0 }, {
+          default: withCtx(() => [
+            createTextVNode(toDisplayString(helper.value), 1)
+          ]),
+          _: 1
+        })) : createCommentVNode("", true),
+        invalid.value ? (openBlock(), createBlock(unref(FieldError), { key: 1 }, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$2, { error: unref(error) }, null, 8, ["error"])
+          ]),
+          _: 1
+        })) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

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

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

package/dist/components/admin/inputs/date-input-format.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Pure date/time format + parse helpers shared by `<DateInput>`,
+ * `<DateTimeInput>`, and `<TimeInput>` — the Vue analog of the inline
+ * `convertDateToString` / `formatX` / `parseX` functions in `@chelone/react`'s
+ * `inputs/{date,date-time,time}-input.tsx`. Extracted to a sibling `.ts` so the
+ * three SFCs share one implementation (and so the formatters stay unit-testable
+ * without mounting a component).
+ */
+/**
+ * Format a form value (string / ISO / `Date` / timestamp / "") to a bare
+ * "YYYY-MM-DD" string for `<input type="date">`. Returns `null` for nullish/empty.
+ */
+export declare function formatDate(value: unknown): string | null;
+/** Whether a raw `<input type="date">` string is empty or a valid date. */
+export declare function isValidDate(raw: string): boolean;
+/**
+ * Format a form value (ISO string / `Date` / timestamp) to the local
+ * `datetime-local` display string. Empty → "" (keeps the input controlled).
+ */
+export declare function formatDateTime(value: unknown): string;
+/**
+ * Parse a local `datetime-local` string back to an ISO 8601 string (browser
+ * timezone). Returns `null` for empty/unparseable so a required validator fires.
+ */
+export declare function parseDateTimeToISO(value: unknown): string | null;
+/** Whether a raw `datetime-local` string is empty or parses to a valid date. */
+export declare function isValidDateTime(raw: string): boolean;
+/**
+ * Format a form value (`Date` / "HH:mm" string) to the "HH:mm" display string.
+ * Empty → "" (keeps the input controlled).
+ */
+export declare function formatTime(value: unknown): string;
+/**
+ * Parse a "HH:mm"/"HH:mm:ss" string to a `Date` (today at that local time), for
+ * dataProvider compatibility. Returns `null` for empty/unparseable so a required
+ * validator still fires.
+ */
+export declare function parseTimeToDate(value: unknown): Date | null;
+/** Whether a raw `<input type="time">` string is empty or a valid time. */
+export declare function isValidTime(raw: string): boolean;

package/dist/components/admin/inputs/date-input-format.js

@@ -0,0 +1,87 @@
+const leftPad = (nb = 2) => (value) => ("0".repeat(nb) + value).slice(-nb);
+const leftPad4 = leftPad(4);
+const leftPad2 = leftPad(2);
+const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+function dateToYmd(value) {
+  if (!(value instanceof Date) || Number.isNaN(value.getDate())) return "";
+  const yyyy = value.getFullYear().toString();
+  const MM = leftPad2(value.getMonth() + 1);
+  const dd = leftPad2(value.getDate());
+  return `${yyyy}-${MM}-${dd}`;
+}
+function formatDate(value) {
+  if (value == null || value === "") return null;
+  if (value instanceof Date) return dateToYmd(value);
+  if (typeof value === "string" && dateRegex.test(value)) return value;
+  return dateToYmd(new Date(value));
+}
+function isValidDate(raw) {
+  if (raw === "") return true;
+  return dateRegex.test(raw) && !Number.isNaN(new Date(raw).getTime());
+}
+const dateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/;
+function dateToLocalDateTime(value) {
+  if (!(value instanceof Date) || Number.isNaN(value.getDate())) return "";
+  const yyyy = leftPad4(value.getFullYear());
+  const MM = leftPad2(value.getMonth() + 1);
+  const dd = leftPad2(value.getDate());
+  const hh = leftPad2(value.getHours());
+  const mm = leftPad2(value.getMinutes());
+  return `${yyyy}-${MM}-${dd}T${hh}:${mm}`;
+}
+function formatDateTime(value) {
+  if (value == null || value === "") return "";
+  if (value instanceof Date) return dateToLocalDateTime(value);
+  if (typeof value === "string" && dateTimeRegex.test(value)) return value;
+  return dateToLocalDateTime(new Date(value));
+}
+function parseDateTimeToISO(value) {
+  if (value == null || value === "") return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function isValidDateTime(raw) {
+  if (raw === "") return true;
+  return !Number.isNaN(new Date(raw).getTime());
+}
+const timeRegex = /^\d{2}:\d{2}(:\d{2})?$/;
+function dateToHm(value) {
+  if (!(value instanceof Date) || Number.isNaN(value.getDate())) return "";
+  const hh = leftPad2(value.getHours());
+  const mm = leftPad2(value.getMinutes());
+  return `${hh}:${mm}`;
+}
+function formatTime(value) {
+  if (value == null || value === "") return "";
+  if (value instanceof Date) return dateToHm(value);
+  if (typeof value === "string" && timeRegex.test(value)) return value;
+  return dateToHm(new Date(value));
+}
+function parseTimeToDate(value) {
+  if (value == null || value === "") return null;
+  if (typeof value === "string" && timeRegex.test(value)) {
+    const [hh = "0", mm = "0", ss = "0"] = value.split(":");
+    const d = /* @__PURE__ */ new Date();
+    d.setHours(
+      Number.parseInt(hh, 10),
+      Number.parseInt(mm, 10),
+      Number.parseInt(ss, 10),
+      0
+    );
+    return d;
+  }
+  return null;
+}
+function isValidTime(raw) {
+  return raw === "" || timeRegex.test(raw);
+}
+export {
+  formatDate,
+  formatDateTime,
+  formatTime,
+  isValidDate,
+  isValidDateTime,
+  isValidTime,
+  parseDateTimeToISO,
+  parseTimeToDate
+};

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

@@ -0,0 +1,31 @@
+/**
+ * `<DateInput>` — native date picker for a "YYYY-MM-DD" value, the Vue analog of
+ * `@chelone/react`'s `inputs/date-input.tsx`. Formats an incoming string / ISO /
+ * `Date` / timestamp to a bare date string and stores the typed date string
+ * (empty → `null` via core's default parse, so a required validator fires).
+ *
+ * Like `<NumberInput>`, it keeps a LOCAL string buffer so a partial entry isn't
+ * clobbered while typing — the twin's uncontrolled `defaultValue` + `key`-remount
+ * dance (born of RHF's `field.ref`) maps to a focused-buffer + external re-sync.
+ */
+import type { Validator } from "@chelone/core";
+/** Props for {@link DateInput}. */
+export interface DateInputProps {
+    source: string;
+    label?: string | false;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    /** Read transform (form value → display string). Default {@link formatDate}. */
+    format?: (value: unknown) => unknown;
+    /** Write transform (display string → stored value). Default core parse (""→null). */
+    parse?: (input: unknown) => unknown;
+    helperText?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    inputClass?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<DateInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DateInputProps> & Readonly<{}>, {
+    label: string | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

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

@@ -0,0 +1,95 @@
+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 { formatDate, isValidDate } from "./date-input-format.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "date-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 ?? formatDate);
+    const { id, value, setValue, blur, error, touched, isRequired } = useInput({
+      source: props.source,
+      defaultValue: props.defaultValue,
+      validate: props.validate,
+      format: (v) => format.value(v),
+      parse: props.parse
+    });
+    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 !== "" && isValidDate(raw)) setValue(raw);
+    }
+    function onBlur() {
+      focused.value = false;
+      if (isValidDate(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: "date",
+            "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/date-input2.vue.js

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

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

@@ -0,0 +1,29 @@
+/**
+ * `<DateTimeInput>` — native `datetime-local` picker, the Vue analog of
+ * `@chelone/react`'s `inputs/date-time-input.tsx`. Formats an incoming ISO
+ * string / `Date` / timestamp to the local `yyyy-MM-ddThh:mm` display value and
+ * parses the entered value back to an ISO 8601 string (browser timezone). Empty
+ * → `null`, so a required validator fires. Same focused-buffer pattern as
+ * `<DateInput>`.
+ */
+import type { Validator } from "@chelone/core";
+/** Props for {@link DateTimeInput}. */
+export interface DateTimeInputProps {
+    source: string;
+    label?: string | false;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    /** Read transform (form value → display string). Default {@link formatDateTime}. */
+    format?: (value: unknown) => unknown;
+    /** Write transform (display string → stored value). Default {@link parseDateTimeToISO}. */
+    parse?: (input: unknown) => unknown;
+    helperText?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    inputClass?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<DateTimeInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DateTimeInputProps> & Readonly<{}>, {
+    label: string | false;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/admin/inputs/date-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 { formatDateTime, parseDateTimeToISO, isValidDateTime } from "./date-input-format.js";
+import { humanizeSource } from "./label-text.js";
+const _hoisted_1 = { key: 0 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "date-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 ?? formatDateTime);
+    const parse = computed(() => props.parse ?? parseDateTimeToISO);
+    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 !== "" && isValidDateTime(raw)) setValue(raw);
+    }
+    function onBlur() {
+      focused.value = false;
+      if (isValidDateTime(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: "datetime-local",
+            "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/date-time-input2.vue.js

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

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

@@ -0,0 +1,25 @@
+/**
+ * `<DurationInput>` — edits an ISO-8601 duration string (`PT2H30M`, `P1DT4H`)
+ * via per-unit numeric boxes, the Vue analog of `@chelone/react`'s
+ * `inputs/duration-input.tsx`. Reads the stored string into day/hour/minute/
+ * second boxes and writes the recomposed ISO string back (all-empty → `null`).
+ */
+import type { Validator } from "@chelone/core";
+type Unit = "d" | "h" | "m" | "s";
+/** Props for {@link DurationInput}. */
+export interface DurationInputProps {
+    source: string;
+    label?: string | false;
+    defaultValue?: unknown;
+    validate?: Validator | readonly Validator[];
+    /** Which units to expose. Default `["d","h","m","s"]`. */
+    units?: readonly Unit[];
+    disabled?: boolean;
+    helperText?: string;
+    class?: string;
+}
+declare const _default: import("vue").DefineComponent<DurationInputProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DurationInputProps> & Readonly<{}>, {
+    label: string | false;
+    units: readonly Unit[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;