@leavepulse/ui 0.68.0 → 0.70.0

package/dist/chunks/LpCopyButton-DzHjnFs0.js

@@ -0,0 +1,133 @@
+import { defineComponent, ref, computed, useAttrs, openBlock, createElementBlock, Fragment, createVNode, withCtx, mergeProps, unref, createElementVNode, normalizeStyle, toDisplayString, createCommentVNode } from "vue";
+import { useClipboard } from "../composables/useClipboard.js";
+import { useLabels } from "../composables/useLpConfig.js";
+import { _ as _sfc_main$2 } from "./LpButton-CVxBfGjd.js";
+import { _ as _sfc_main$3 } from "./LpIcon-HJP5xMz4.js";
+import { _ as _sfc_main$1 } from "./LpTooltip-Cz8SQwRt.js";
+const _hoisted_1 = { key: 0 };
+const _hoisted_2 = {
+  class: "sr-only",
+  role: "status",
+  "aria-live": "polite"
+};
+const __default__ = { inheritAttrs: false };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "LpCopyButton",
+  props: {
+    value: {},
+    size: { default: "sm" },
+    iconSize: {},
+    variant: { default: "ghost" },
+    label: {},
+    toast: { type: [String, Boolean], default: false },
+    copied: { type: Boolean },
+    disabled: { type: Boolean },
+    side: { default: "top" },
+    labels: {}
+  },
+  emits: ["copied", "error"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const text = useLabels(
+      "copyButton",
+      { copy: "Copy", copied: "Copied", failed: "Couldn't copy" },
+      () => props.labels
+    );
+    const { copy, copied: justCopied } = useClipboard();
+    const busy = ref(false);
+    const failed = ref(false);
+    let failTimer;
+    const state = computed(
+      () => failed.value ? "failed" : justCopied.value || props.copied ? "copied" : "idle"
+    );
+    async function run() {
+      if (busy.value || props.disabled) return;
+      let value;
+      try {
+        let raw = props.value;
+        if (typeof raw === "function") {
+          busy.value = true;
+          raw = await raw();
+        }
+        value = raw instanceof Blob ? raw : String(raw);
+      } catch (error) {
+        busy.value = false;
+        fail(error);
+        return;
+      }
+      busy.value = false;
+      if (await copy(value, { toast: props.toast })) {
+        failed.value = false;
+        if (value instanceof Blob) emit("copied", "", value);
+        else emit("copied", value);
+      } else fail(new Error("Clipboard unavailable"));
+    }
+    function fail(error) {
+      failed.value = true;
+      clearTimeout(failTimer);
+      failTimer = setTimeout(() => failed.value = false, 1800);
+      emit("error", error);
+    }
+    const tip = computed(
+      () => state.value === "copied" ? text.value.copied : state.value === "failed" ? text.value.failed : text.value.copy
+    );
+    const iconSize = computed(() => props.iconSize ?? { xs: 13, sm: 14, md: 16, lg: 16 }[props.size]);
+    const attrs = useAttrs();
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(Fragment, null, [
+        createVNode(_sfc_main$1, {
+          content: tip.value,
+          label: !__props.label,
+          side: __props.side
+        }, {
+          default: withCtx(() => [
+            createVNode(_sfc_main$2, mergeProps(unref(attrs), {
+              variant: __props.variant,
+              size: __props.size,
+              square: !__props.label,
+              disabled: __props.disabled,
+              loading: busy.value,
+              "data-state": state.value,
+              onClick: run
+            }), {
+              default: withCtx(() => [
+                createElementVNode("span", {
+                  class: "relative inline-grid shrink-0 place-items-center",
+                  style: normalizeStyle({ width: `${iconSize.value}px`, height: `${iconSize.value}px` })
+                }, [
+                  createVNode(_sfc_main$3, {
+                    name: "lucide:copy",
+                    size: iconSize.value,
+                    class: "lp-glyph-swap col-start-1 row-start-1",
+                    "data-on": state.value === "idle" || void 0
+                  }, null, 8, ["size", "data-on"]),
+                  createVNode(_sfc_main$3, {
+                    name: "lucide:check",
+                    size: iconSize.value,
+                    class: "lp-glyph-swap col-start-1 row-start-1 text-action",
+                    "data-on": state.value === "copied" || void 0
+                  }, null, 8, ["size", "data-on"]),
+                  createVNode(_sfc_main$3, {
+                    name: "lucide:x",
+                    size: iconSize.value,
+                    class: "lp-glyph-swap col-start-1 row-start-1 text-danger",
+                    "data-on": state.value === "failed" || void 0
+                  }, null, 8, ["size", "data-on"])
+                ], 4),
+                __props.label ? (openBlock(), createElementBlock("span", _hoisted_1, toDisplayString(__props.label), 1)) : createCommentVNode("", true)
+              ]),
+              _: 1
+            }, 16, ["variant", "size", "square", "disabled", "loading", "data-state"])
+          ]),
+          _: 1
+        }, 8, ["content", "label", "side"]),
+        createElementVNode("span", _hoisted_2, toDisplayString(state.value === "idle" ? "" : tip.value), 1)
+      ], 64);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/chunks/LpCountdown-Dtq1ihlJ.js

@@ -0,0 +1,231 @@
+import { defineComponent, ref, computed, watch, openBlock, createElementBlock, mergeProps, unref, createBlock, createCommentVNode, createElementVNode, normalizeClass, createVNode, withCtx, Transition, renderSlot, Fragment, renderList, toDisplayString } from "vue";
+import { useLabels } from "../composables/useLpConfig.js";
+import { useMergedAttrs } from "../composables/useMergedClass.js";
+import { useNow } from "../composables/useNow.js";
+import { _ as _sfc_main$1 } from "./LpProgress-CE-m5OpD.js";
+import { _ as _sfc_main$3 } from "./LpRollingText-DB7upf-5.js";
+import { _ as _sfc_main$2 } from "./LpShift-DXNsauQZ.js";
+import { DEFAULT_UNIT_LABELS, toEpoch, ceilToSecond, timeParts, resolveFormat, padPart, formatTime, DEFAULT_MILESTONES, crossedMilestone, msToNextSecond } from "../components/timeSpan.js";
+const _hoisted_1 = ["data-urgent", "data-done"];
+const _hoisted_2 = ["aria-label"];
+const _hoisted_3 = {
+  key: "done",
+  class: "inline-flex font-sans"
+};
+const _hoisted_4 = {
+  key: "time",
+  class: "inline-flex items-baseline whitespace-nowrap",
+  "aria-hidden": "true"
+};
+const _hoisted_5 = {
+  key: 0,
+  class: "px-px"
+};
+const _hoisted_6 = {
+  key: 2,
+  class: "sr-only",
+  "aria-live": "polite",
+  "aria-atomic": "true"
+};
+const __default__ = { inheritAttrs: false };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "LpCountdown",
+  props: {
+    to: {},
+    seconds: {},
+    from: {},
+    format: { default: "auto" },
+    places: { default: 2 },
+    paused: { type: Boolean },
+    progress: {},
+    ringSize: { default: 56 },
+    urgentAt: {},
+    announce: { type: [Boolean, Array], default: true },
+    labels: {}
+  },
+  emits: ["done"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const text = useLabels("countdown", { left: "{time} left", done: "Time is up" }, () => props.labels);
+    const units = useLabels("time", DEFAULT_UNIT_LABELS);
+    const announcement = ref("");
+    const startedAt = ref(Date.now());
+    const deadline = computed(() => {
+      const to = toEpoch(props.to);
+      if (!Number.isNaN(to)) return to;
+      if (typeof props.seconds === "number" && Number.isFinite(props.seconds)) return startedAt.value + props.seconds * 1e3;
+      return Number.NaN;
+    });
+    const total = computed(() => {
+      if (!Number.isNaN(toEpoch(props.to))) {
+        const from = toEpoch(props.from);
+        return Number.isNaN(from) ? Number.NaN : deadline.value - from;
+      }
+      return typeof props.seconds === "number" ? props.seconds * 1e3 : Number.NaN;
+    });
+    const frozen = ref(null);
+    let pausedAt = 0;
+    watch(
+      () => props.paused,
+      (paused) => {
+        if (paused) {
+          pausedAt = Date.now();
+          frozen.value = Math.max(0, deadline.value - pausedAt);
+        } else if (frozen.value !== null) {
+          if (Number.isNaN(toEpoch(props.to))) startedAt.value += Date.now() - pausedAt;
+          frozen.value = null;
+        }
+      },
+      { immediate: true }
+    );
+    const running = ref(true);
+    const now = useNow(() => running.value && !props.paused && Number.isFinite(deadline.value), {
+      nextIn: (at) => msToNextSecond(deadline.value - at)
+    });
+    const remaining = computed(() => {
+      if (frozen.value !== null) return frozen.value;
+      const left = deadline.value - now.value;
+      return Number.isFinite(left) ? Math.max(0, left) : 0;
+    });
+    const shown = computed(() => ceilToSecond(remaining.value));
+    const isDone = computed(() => !Number.isNaN(deadline.value) && remaining.value <= 0);
+    watch(isDone, (done) => {
+      running.value = !done;
+    }, { immediate: true });
+    let fired = false;
+    watch(
+      isDone,
+      (done) => {
+        if (!done) {
+          fired = false;
+          return;
+        }
+        if (fired) return;
+        fired = true;
+        emit("done");
+        if (props.announce !== false) announcement.value = text.value.done;
+      },
+      { immediate: true }
+    );
+    function restart() {
+      announcement.value = "";
+      startedAt.value = Date.now();
+      now.value = startedAt.value;
+      if (props.paused) {
+        pausedAt = startedAt.value;
+        frozen.value = Math.max(0, deadline.value - pausedAt);
+      }
+    }
+    watch(() => props.seconds, () => {
+      if (Number.isNaN(toEpoch(props.to))) restart();
+    });
+    __expose({ restart, remaining });
+    const parts = computed(() => timeParts(shown.value, props.format, units.value, props.places));
+    const clock = computed(() => resolveFormat(shown.value, props.format) === "clock");
+    const cells = computed(
+      () => parts.value.map((part) => {
+        const digits = padPart(part).split("");
+        return { part, digits: digits.map((d, i) => ({ d, key: `${part.unit}${digits.length - i}` })) };
+      })
+    );
+    const spokenTime = computed(() => formatTime(shown.value, "units", units.value, 2));
+    const milestones = computed(() => Array.isArray(props.announce) ? props.announce : DEFAULT_MILESTONES);
+    watch(remaining, (after, before) => {
+      if (props.announce === false || before === void 0 || props.paused) return;
+      const mark = crossedMilestone(before, after, milestones.value);
+      if (mark !== null && after > 0) {
+        announcement.value = text.value.left.replace("{time}", formatTime(ceilToSecond(after), "units", units.value, 2));
+      }
+    });
+    const urgent = computed(
+      () => props.urgentAt !== void 0 && !isDone.value && remaining.value <= props.urgentAt * 1e3
+    );
+    const fraction = computed(() => {
+      if (!(total.value > 0)) return null;
+      return Math.max(0, Math.min(1, remaining.value / total.value));
+    });
+    const { class: rootClass, attrs: rest } = useMergedAttrs(
+      () => props.progress === "bar" ? "flex w-full min-w-0 flex-col gap-1.5" : "relative inline-flex items-center justify-center align-baseline"
+    );
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("span", mergeProps({
+        class: unref(rootClass),
+        "data-urgent": urgent.value || void 0,
+        "data-done": isDone.value || void 0
+      }, unref(rest)), [
+        __props.progress === "ring" && fraction.value !== null ? (openBlock(), createBlock(_sfc_main$1, {
+          key: 0,
+          variant: "ring",
+          value: fraction.value * 100,
+          size: __props.ringSize,
+          thickness: Math.max(3, Math.round(__props.ringSize / 14)),
+          tone: urgent.value ? "danger" : "brand",
+          "animate-on-mount": false,
+          duration: 1e3,
+          "aria-hidden": "true"
+        }, null, 8, ["value", "size", "thickness", "tone"])) : createCommentVNode("", true),
+        createElementVNode("span", {
+          role: "timer",
+          "aria-label": isDone.value ? unref(text).done : spokenTime.value,
+          class: normalizeClass(["inline-flex items-baseline font-mono tabular-nums transition-colors duration-(--duration-medium) motion-reduce:transition-none", [
+            urgent.value ? "text-danger" : "",
+            __props.progress === "ring" && fraction.value !== null ? "absolute text-xs font-medium" : ""
+          ]])
+        }, [
+          createVNode(_sfc_main$2, { axis: "width" }, {
+            default: withCtx(() => [
+              createVNode(Transition, {
+                mode: "out-in",
+                "enter-active-class": "transition-opacity duration-(--duration-fast) ease-(--ease-emphasized) motion-reduce:transition-none",
+                "enter-from-class": "opacity-0",
+                "leave-active-class": "transition-opacity duration-(--duration-fast) ease-out motion-reduce:transition-none",
+                "leave-to-class": "opacity-0"
+              }, {
+                default: withCtx(() => [
+                  isDone.value && _ctx.$slots.done ? (openBlock(), createElementBlock("span", _hoisted_3, [
+                    renderSlot(_ctx.$slots, "done")
+                  ])) : (openBlock(), createElementBlock("span", _hoisted_4, [
+                    (openBlock(true), createElementBlock(Fragment, null, renderList(cells.value, (cell, ci) => {
+                      return openBlock(), createElementBlock(Fragment, {
+                        key: cell.part.unit
+                      }, [
+                        (openBlock(true), createElementBlock(Fragment, null, renderList(cell.digits, (digit) => {
+                          return openBlock(), createBlock(_sfc_main$3, {
+                            key: digit.key,
+                            value: digit.d,
+                            direction: "down",
+                            duration: 260
+                          }, null, 8, ["value"]);
+                        }), 128)),
+                        clock.value ? (openBlock(), createElementBlock("span", _hoisted_5, toDisplayString(cell.part.after), 1)) : (openBlock(), createElementBlock("span", {
+                          key: 1,
+                          class: normalizeClass(["font-sans text-[0.85em] text-muted", ci < cells.value.length - 1 && "mr-[0.35em]"])
+                        }, toDisplayString(cell.part.after), 3))
+                      ], 64);
+                    }), 128))
+                  ]))
+                ]),
+                _: 3
+              })
+            ]),
+            _: 3
+          })
+        ], 10, _hoisted_2),
+        __props.progress === "bar" && fraction.value !== null ? (openBlock(), createBlock(_sfc_main$1, {
+          key: 1,
+          value: fraction.value * 100,
+          tone: urgent.value ? "danger" : "brand",
+          "animate-on-mount": false,
+          duration: 1e3,
+          "aria-hidden": "true"
+        }, null, 8, ["value", "tone"])) : createCommentVNode("", true),
+        __props.announce !== false ? (openBlock(), createElementBlock("span", _hoisted_6, toDisplayString(announcement.value), 1)) : createCommentVNode("", true)
+      ], 16, _hoisted_1);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/chunks/LpDataList-B-5nHfNw.js

@@ -0,0 +1,120 @@
+import { defineComponent, useSlots, computed, openBlock, createElementBlock, mergeProps, unref, createVNode, TransitionGroup, normalizeClass, withCtx, Fragment, renderList, createElementVNode, renderSlot, createTextVNode, toDisplayString, createBlock, createCommentVNode } from "vue";
+import { useLabels } from "../composables/useLpConfig.js";
+import { useMergedAttrs } from "../composables/useMergedClass.js";
+import { _ as _sfc_main$4 } from "./LpCopyButton-DzHjnFs0.js";
+import { _ as _sfc_main$2 } from "./LpIcon-HJP5xMz4.js";
+import { _ as _sfc_main$3 } from "./LpRollingText-DB7upf-5.js";
+import { _ as _sfc_main$1 } from "./LpTooltip-Cz8SQwRt.js";
+const _hoisted_1 = { class: "flex min-w-0 items-center gap-1 text-muted" };
+const _hoisted_2 = ["aria-label"];
+const _hoisted_3 = { class: "min-w-0 break-words" };
+const _hoisted_4 = {
+  key: 1,
+  class: "text-muted"
+};
+const __default__ = { inheritAttrs: false };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "LpDataList",
+  props: {
+    items: {},
+    layout: { default: "auto" },
+    divided: { type: Boolean },
+    size: { default: "md" },
+    labels: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const text = useLabels("dataList", { empty: "—" }, () => props.labels);
+    const slots = useSlots();
+    const keyOf = (item) => item.key ?? item.label;
+    const isEmpty = (value) => value === null || value === void 0 || value === "";
+    const rolls = (value) => !isEmpty(value) && String(value).length <= 48;
+    const GRID = {
+      auto: "grid-cols-1 @xs:grid-cols-[fit-content(40%)_minmax(0,1fr)]",
+      horizontal: "grid-cols-[fit-content(40%)_minmax(0,1fr)]",
+      stacked: "grid-cols-1"
+    };
+    const ROW = {
+      auto: "gap-0.5 @xs:col-span-2 @xs:grid-cols-subgrid @xs:gap-x-6",
+      horizontal: "col-span-2 grid-cols-subgrid gap-x-6",
+      stacked: "gap-0.5"
+    };
+    const { class: rootClass, attrs: rest } = useMergedAttrs(() => "@container w-full");
+    const pad = computed(() => props.size === "sm" ? "py-1.5 text-xs" : "py-2.5 text-sm");
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", mergeProps({ class: unref(rootClass) }, unref(rest)), [
+        createVNode(TransitionGroup, {
+          tag: "dl",
+          class: normalizeClass(["grid", GRID[__props.layout]]),
+          "move-class": "transition-transform duration-(--duration-medium) ease-(--ease-emphasized) motion-reduce:transition-none",
+          "enter-active-class": "transition-opacity duration-(--duration-medium) motion-reduce:transition-none",
+          "enter-from-class": "opacity-0",
+          "leave-active-class": "hidden"
+        }, {
+          default: withCtx(() => [
+            (openBlock(true), createElementBlock(Fragment, null, renderList(__props.items, (item, i) => {
+              return openBlock(), createElementBlock("div", {
+                key: keyOf(item),
+                class: normalizeClass(["group/row grid items-baseline", [ROW[__props.layout], pad.value, __props.divided && i > 0 ? "border-t border-line" : ""]])
+              }, [
+                createElementVNode("dt", _hoisted_1, [
+                  renderSlot(_ctx.$slots, `label-${keyOf(item)}`, { item }, () => [
+                    renderSlot(_ctx.$slots, "label", { item }, () => [
+                      createTextVNode(toDisplayString(item.label), 1)
+                    ])
+                  ]),
+                  item.hint ? (openBlock(), createBlock(_sfc_main$1, {
+                    key: 0,
+                    content: item.hint
+                  }, {
+                    default: withCtx(() => [
+                      createElementVNode("button", {
+                        type: "button",
+                        class: "grid size-4 shrink-0 place-items-center rounded-full text-muted/80 outline-none hover:text-ink focus-visible:ring-2 focus-visible:ring-ring",
+                        "aria-label": item.hint
+                      }, [
+                        createVNode(_sfc_main$2, {
+                          name: "lucide:info",
+                          size: 12
+                        })
+                      ], 8, _hoisted_2)
+                    ]),
+                    _: 2
+                  }, 1032, ["content"])) : createCommentVNode("", true)
+                ]),
+                createElementVNode("dd", {
+                  class: normalizeClass(["flex min-w-0 items-center gap-1.5 text-ink", item.mono ? "font-mono" : ""])
+                }, [
+                  createElementVNode("span", _hoisted_3, [
+                    unref(slots)[`value-${keyOf(item)}`] || unref(slots).value ? renderSlot(_ctx.$slots, unref(slots)[`value-${keyOf(item)}`] ? `value-${keyOf(item)}` : "value", {
+                      key: 0,
+                      item,
+                      value: item.value
+                    }) : isEmpty(item.value) ? (openBlock(), createElementBlock("span", _hoisted_4, toDisplayString(unref(text).empty), 1)) : rolls(item.value) ? (openBlock(), createBlock(_sfc_main$3, {
+                      key: 2,
+                      value: item.value,
+                      align: "start"
+                    }, null, 8, ["value"])) : (openBlock(), createElementBlock(Fragment, { key: 3 }, [
+                      createTextVNode(toDisplayString(item.value), 1)
+                    ], 64))
+                  ]),
+                  item.copyable && !isEmpty(item.value) ? (openBlock(), createBlock(_sfc_main$4, {
+                    key: 0,
+                    value: String(item.value),
+                    size: "xs",
+                    class: "-my-1 size-6 shrink-0 opacity-0 transition-opacity duration-(--duration-fast) group-hover/row:opacity-100 focus-visible:opacity-100 data-[state=copied]:opacity-100 [@media(hover:none)]:opacity-100"
+                  }, null, 8, ["value"])) : createCommentVNode("", true)
+                ], 2)
+              ], 2);
+            }), 128))
+          ]),
+          _: 3
+        }, 8, ["class"])
+      ], 16);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/chunks/LpDatePicker-BUe1VUC0.js

@@ -0,0 +1,168 @@
+import { defineComponent, ref, computed, useAttrs, openBlock, createBlock, mergeProps, unref, withCtx, createElementVNode, createVNode, createElementBlock, toDisplayString, createCommentVNode } from "vue";
+import { useFieldControl } from "../composables/useField.js";
+import { useLocale } from "../composables/useLocale.js";
+import { useLabels } from "../composables/useLpConfig.js";
+import { defaultDatePresets, dayAllowed } from "../components/dateRange.js";
+import { _ as _sfc_main$2 } from "./LpCalendar-pVL91-Pl.js";
+import { _ as _sfc_main$3 } from "./LpIcon-HJP5xMz4.js";
+import { _ as _sfc_main$1 } from "./PickerField-CHRS1h7K.js";
+import { _ as _sfc_main$4 } from "./LpTimeField-BFQVf_PW.js";
+const _hoisted_1 = { class: "flex flex-col" };
+const _hoisted_2 = {
+  key: 0,
+  class: "flex items-center gap-2 border-t border-line px-3 py-2"
+};
+const __default__ = { inheritAttrs: false };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  __name: "LpDatePicker",
+  props: {
+    modelValue: {},
+    placeholder: {},
+    min: {},
+    max: {},
+    isDisabled: {},
+    isDateUnavailable: {},
+    presets: { type: [Array, Boolean] },
+    clearable: { type: Boolean },
+    disabled: { type: Boolean },
+    invalid: { type: Boolean },
+    size: { default: "md" },
+    locale: {},
+    format: { default: () => ({ year: "numeric", month: "short", day: "numeric" }) },
+    time: { type: Boolean },
+    defaultTime: { default: "00:00" },
+    doneLabel: {},
+    labels: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = ref(false);
+    const day = computed(() => (props.modelValue || "").slice(0, 10));
+    const minute = computed(() => {
+      const at = (props.modelValue || "").slice(11, 16);
+      return /^\d{2}:\d{2}$/.test(at) ? at : "";
+    });
+    const locale = useLocale(() => props.locale);
+    const display = computed(() => {
+      if (!props.modelValue) return "";
+      const [y, m, d] = day.value.split("-").map(Number);
+      if (!y || !m || !d) return props.modelValue;
+      const shown = new Intl.DateTimeFormat(locale.value, props.format).format(new Date(y, m - 1, d));
+      return props.time && minute.value ? `${shown}, ${minute.value}` : shown;
+    });
+    function onPick(picked) {
+      const v = picked ?? (day.value || void 0);
+      if (!props.time) {
+        emit("update:modelValue", v);
+        open.value = false;
+        return;
+      }
+      emit("update:modelValue", v ? `${v}T${minute.value || props.defaultTime}` : void 0);
+    }
+    function onTime(at) {
+      if (!day.value) return;
+      emit("update:modelValue", `${day.value}T${at || props.defaultTime}`);
+    }
+    function clear() {
+      emit("update:modelValue", void 0);
+    }
+    const attrs = useAttrs();
+    const field = useFieldControl(() => ({
+      wrapped: false,
+      id: typeof attrs.id === "string" ? attrs.id : void 0,
+      invalid: props.invalid,
+      disabled: props.disabled
+    }));
+    const text = useLabels(
+      "datePicker",
+      {
+        placeholder: "Pick a date",
+        clear: "Clear",
+        done: "Done",
+        presets: "Presets",
+        today: "Today",
+        tomorrow: "Tomorrow",
+        inWeek: "In a week"
+      },
+      () => props.labels
+    );
+    const presetList = computed(() => {
+      if (Array.isArray(props.presets)) return props.presets;
+      return props.presets ? defaultDatePresets(text.value) : [];
+    });
+    function presetFits(preset) {
+      return dayAllowed(preset.date(), props);
+    }
+    function pickPreset(preset) {
+      if (presetFits(preset)) onPick(preset.date());
+    }
+    const showClear = computed(() => props.clearable && !!props.modelValue && !field.value.disabled);
+    const presetOptions = computed(() => presetList.value.map((preset) => ({
+      label: preset.label,
+      disabled: !presetFits(preset),
+      selected: !!day.value && day.value === preset.date(),
+      select: () => pickPreset(preset)
+    })));
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$1, mergeProps(unref(attrs), {
+        open: open.value,
+        "onUpdate:open": _cache[2] || (_cache[2] = ($event) => open.value = $event),
+        field: unref(field),
+        display: display.value,
+        placeholder: __props.placeholder ?? unref(text).placeholder,
+        icon: "lucide:calendar",
+        size: __props.size,
+        clearable: showClear.value,
+        "clear-label": unref(text).clear,
+        "presets-label": unref(text).presets,
+        presets: presetOptions.value,
+        "presets-class": "sm:w-36",
+        onClear: clear
+      }), {
+        default: withCtx(() => [
+          createElementVNode("div", _hoisted_1, [
+            createVNode(_sfc_main$2, {
+              "model-value": day.value,
+              min: __props.min,
+              max: __props.max,
+              "is-disabled": __props.isDisabled,
+              "is-date-unavailable": __props.isDateUnavailable,
+              locale: unref(locale),
+              labels: __props.labels,
+              class: "border-0 bg-transparent",
+              "onUpdate:modelValue": onPick
+            }, null, 8, ["model-value", "min", "max", "is-disabled", "is-date-unavailable", "locale", "labels"]),
+            __props.time ? (openBlock(), createElementBlock("div", _hoisted_2, [
+              createVNode(_sfc_main$3, {
+                name: "lucide:clock",
+                size: 15,
+                class: "shrink-0 text-muted"
+              }),
+              createVNode(_sfc_main$4, {
+                "model-value": minute.value || void 0,
+                disabled: !day.value,
+                icon: false,
+                locale: unref(locale),
+                size: "sm",
+                class: "flex-1",
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = (at) => onTime(at || ""))
+              }, null, 8, ["model-value", "disabled", "locale"]),
+              createElementVNode("button", {
+                type: "button",
+                class: "shrink-0 rounded-control px-2 py-1 text-xs text-muted transition-colors hover:text-ink",
+                onClick: _cache[1] || (_cache[1] = ($event) => open.value = false)
+              }, toDisplayString(__props.doneLabel ?? unref(text).done), 1)
+            ])) : createCommentVNode("", true)
+          ])
+        ]),
+        _: 1
+      }, 16, ["open", "field", "display", "placeholder", "size", "clearable", "clear-label", "presets-label", "presets"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};