@brumaombra/ui-vintage 0.3.0 → 0.5.0

package/dist/MessageToast-uKrMyOZf.js

@@ -0,0 +1,79 @@
+import { defineComponent, computed, openBlock, createBlock, Transition, withCtx, unref, createElementBlock, createElementVNode, createVNode, normalizeClass, toDisplayString, createCommentVNode } from "vue";
+import { g as Ay, A as AE, $ as $o, d as dp } from "./index.min-CZ9FIOXr.js";
+import { H as HugeiconsIcon } from "./HugeiconsIcon.vue-By2RXWWz.js";
+import { getUiVintageRuntimeMessage } from "./i18n.js";
+import { Button as _sfc_main$1 } from "./button.js";
+import { messageToastState, closeMessageToast } from "./message-toast.js";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-1tPrXgE0.js";
+const _hoisted_1 = ["aria-live"];
+const _hoisted_2 = { class: "flex items-center gap-4" };
+const _hoisted_3 = { class: "m-0 flex-1 text-sm font-medium leading-5" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "MessageToast",
+  setup(__props) {
+    const currentToast = computed(() => messageToastState.current);
+    const closeAriaLabel = computed(() => getUiVintageRuntimeMessage("ui.buttons.close", "Close"));
+    const toastType = computed(() => {
+      var _a;
+      return ((_a = currentToast.value) == null ? void 0 : _a.type) ?? "success";
+    });
+    const toastIcon = computed(() => {
+      if (toastType.value === "success") return Ay;
+      return toastType.value === "info" ? AE : $o;
+    });
+    const toastIconClasses = computed(() => {
+      if (toastType.value === "error") return "text-red-600 dark:text-red-400";
+      if (toastType.value === "warning") return "text-amber-600 dark:text-amber-400";
+      if (toastType.value === "info") return "text-blue-600 dark:text-blue-400";
+      return "text-green-600 dark:text-green-400";
+    });
+    const toastAriaLive = computed(() => {
+      if (toastType.value === "error" || toastType.value === "warning") return "assertive";
+      return "polite";
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Transition, { name: "toast" }, {
+        default: withCtx(() => {
+          var _a;
+          return [
+            unref(messageToastState).current && unref(messageToastState).isOpen ? (openBlock(), createElementBlock("div", {
+              key: 0,
+              class: "fixed inset-x-3 bottom-3 z-30 rounded border border-border bg-card p-4 text-card-foreground transition-colors duration-300 ease-in-out sm:inset-x-auto sm:right-6 sm:bottom-6 sm:max-w-[350px] sm:min-w-[250px]",
+              role: "alert",
+              "aria-live": toastAriaLive.value,
+              "aria-atomic": "true"
+            }, [
+              createElementVNode("div", _hoisted_2, [
+                createVNode(unref(HugeiconsIcon), {
+                  icon: toastIcon.value,
+                  class: normalizeClass(["size-5", toastIconClasses.value])
+                }, null, 8, ["icon", "class"]),
+                createElementVNode("p", _hoisted_3, toDisplayString((_a = currentToast.value) == null ? void 0 : _a.message), 1),
+                createVNode(unref(_sfc_main$1), {
+                  variant: "ghost",
+                  size: "icon-sm",
+                  class: "-me-1 h-auto min-h-0 w-auto p-0 opacity-70 hover:opacity-100",
+                  "aria-label": closeAriaLabel.value,
+                  onClick: unref(closeMessageToast)
+                }, {
+                  default: withCtx(() => [
+                    createVNode(unref(HugeiconsIcon), {
+                      icon: unref(dp),
+                      class: "size-4"
+                    }, null, 8, ["icon"])
+                  ]),
+                  _: 1
+                }, 8, ["aria-label", "onClick"])
+              ])
+            ], 8, _hoisted_1)) : createCommentVNode("", true)
+          ];
+        }),
+        _: 1
+      });
+    };
+  }
+});
+const MessageToast = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-edc1d178"]]);
+export {
+  MessageToast as default
+};

package/dist/{NativeSelectOption.vue_vue_type_script_setup_true_lang-Ce5VmA0n.js → NativeSelectOption.vue_vue_type_script_setup_true_lang-CNcUI9Yh.js}

@@ -1,8 +1,9 @@
 import { defineComponent, openBlock, createElementBlock, withDirectives, createElementVNode, mergeProps, unref, isRef, renderSlot, vModelSelect, createVNode, normalizeClass } from "vue";
-import { u as useVModel } from "./index-Cq9Ekgtb.js";
-import { H as HugeiconsIcon, d as dn } from "./HugeiconsIcon.vue-BJ-_Wtmk.js";
+import { a as useVModel } from "./index-Dw56kNV0.js";
+import { a as dn } from "./index.min-CZ9FIOXr.js";
+import { H as HugeiconsIcon } from "./HugeiconsIcon.vue-By2RXWWz.js";
 import { c as cn } from "./utils-Bz4m9VPB.js";
-import { r as reactiveOmit } from "./index-qGMU40e1.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
 const _hoisted_1 = {
   class: "group/native-select relative w-fit has-[select:disabled]:opacity-50",
   "data-slot": "native-select-wrapper"

package/dist/{PopoverTrigger.vue_vue_type_script_setup_true_lang-DFZJvU_P.js → PopoverTrigger.vue_vue_type_script_setup_true_lang-Cf33q_yT.js}

@@ -1,14 +1,17 @@
 import { defineComponent, toRefs, ref, openBlock, createBlock, unref, withCtx, renderSlot, createVNode, mergeProps, withModifiers, normalizeProps, guardReactiveProps, onMounted, resolveDynamicComponent } from "vue";
-import { c as createContext, a as useForwardProps, u as useForwardPropsEmits } from "./useForwardPropsEmits-DmumnZO5.js";
-import { u as useForwardExpose } from "./useForwardExpose-BiRQH8eO.js";
-import { D as DismissableLayer_default, u as useId, P as Presence_default, T as Teleport_default } from "./Teleport-CV0tKbq5.js";
-import { F as FocusScope_default, u as useBodyScrollLock, a as useHideOthers } from "./FocusScope-DYbCtSNc.js";
-import { u as useFocusGuards } from "./useFocusGuards-WYWvpJy2.js";
-import { a as PopperRoot_default, b as PopperContent_default, P as PopperAnchor_default } from "./PopperContent-h-thLTz8.js";
-import { r as reactiveOmit } from "./index-qGMU40e1.js";
+import { a as useForwardProps, u as useForwardPropsEmits } from "./useForwardPropsEmits-GlUGKcIz.js";
+import { u as useForwardExpose } from "./useForwardExpose-BcX3VRdS.js";
+import { u as useId } from "./useId-CF6wz41D.js";
+import { P as Presence_default } from "./Presence-CTmUEdMR.js";
+import { F as FocusScope_default, a as useBodyScrollLock, u as useHideOthers } from "./FocusScope-mzbqk6Y_.js";
+import { u as useFocusGuards } from "./useFocusGuards-2C1jyYW5.js";
+import { D as DismissableLayer_default, T as Teleport_default } from "./Teleport-DTOwRCqx.js";
+import { a as PopperRoot_default, b as PopperContent_default, P as PopperAnchor_default } from "./PopperContent-DUJ8a4i0.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
 import { c as cn } from "./utils-Bz4m9VPB.js";
 import { P as Primitive } from "./Primitive-D3IcFg81.js";
-import { u as useVModel } from "./index-Cq9Ekgtb.js";
+import { c as createContext } from "./createContext-BabAT1K8.js";
+import { a as useVModel } from "./index-Dw56kNV0.js";
 const [injectPopoverRootContext, providePopoverRootContext] = createContext("PopoverRoot");
 var PopoverRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
   __name: "PopoverRoot",

package/dist/{PopperContent-h-thLTz8.js → PopperContent-DUJ8a4i0.js}

@@ -1,9 +1,9 @@
-import { u as useForwardExpose } from "./useForwardExpose-BiRQH8eO.js";
+import { u as useForwardExpose } from "./useForwardExpose-BcX3VRdS.js";
 import { P as Primitive } from "./Primitive-D3IcFg81.js";
 import { defineComponent, ref, renderSlot, watchPostEffect, openBlock, createBlock, unref, withCtx, computed, shallowRef, watch, getCurrentScope, onScopeDispose, shallowReadonly, watchEffect, createElementBlock, normalizeStyle, createVNode, mergeProps, mergeDefaults } from "vue";
-import { c as createContext } from "./useForwardPropsEmits-DmumnZO5.js";
-import { u as useSize } from "./useSize-BLYTFgnQ.js";
-import { n as computedEager } from "./index-qGMU40e1.js";
+import { c as createContext } from "./createContext-BabAT1K8.js";
+import { u as useSize } from "./useSize-DUgGY9t1.js";
+import { n as computedEager } from "./index-DDJjWaIl.js";
 const [injectPopperRootContext, providePopperRootContext] = createContext("PopperRoot");
 var PopperRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
   inheritAttrs: false,

package/dist/Presence-CTmUEdMR.js

@@ -0,0 +1,168 @@
+import { r as renderSlotFragments } from "./Primitive-D3IcFg81.js";
+import { ref, watch, nextTick, onUnmounted, computed, defineComponent, toRefs, getCurrentInstance, h } from "vue";
+import { d as defaultWindow, u as unrefElement } from "./index-Dw56kNV0.js";
+import { i as isClient } from "./index-DDJjWaIl.js";
+function useStateMachine(initialState, machine) {
+  const state = ref(initialState);
+  function reducer(event) {
+    const nextState = machine[state.value][event];
+    return nextState ?? state.value;
+  }
+  const dispatch = (event) => {
+    state.value = reducer(event);
+  };
+  return {
+    state,
+    dispatch
+  };
+}
+function usePresence(present, node) {
+  var _a;
+  const stylesRef = ref({});
+  const prevAnimationNameRef = ref("none");
+  const prevPresentRef = ref(present);
+  const initialState = present.value ? "mounted" : "unmounted";
+  let timeoutId;
+  const ownerWindow = ((_a = node.value) == null ? void 0 : _a.ownerDocument.defaultView) ?? defaultWindow;
+  const { state, dispatch } = useStateMachine(initialState, {
+    mounted: {
+      UNMOUNT: "unmounted",
+      ANIMATION_OUT: "unmountSuspended"
+    },
+    unmountSuspended: {
+      MOUNT: "mounted",
+      ANIMATION_END: "unmounted"
+    },
+    unmounted: { MOUNT: "mounted" }
+  });
+  const dispatchCustomEvent = (name) => {
+    var _a2;
+    if (isClient) {
+      const customEvent = new CustomEvent(name, {
+        bubbles: false,
+        cancelable: false
+      });
+      (_a2 = node.value) == null ? void 0 : _a2.dispatchEvent(customEvent);
+    }
+  };
+  watch(present, async (currentPresent, prevPresent) => {
+    var _a2;
+    const hasPresentChanged = prevPresent !== currentPresent;
+    await nextTick();
+    if (hasPresentChanged) {
+      const prevAnimationName = prevAnimationNameRef.value;
+      const currentAnimationName = getAnimationName(node.value);
+      if (currentPresent) {
+        dispatch("MOUNT");
+        dispatchCustomEvent("enter");
+        if (currentAnimationName === "none") dispatchCustomEvent("after-enter");
+      } else if (currentAnimationName === "none" || currentAnimationName === "undefined" || ((_a2 = stylesRef.value) == null ? void 0 : _a2.display) === "none") {
+        dispatch("UNMOUNT");
+        dispatchCustomEvent("leave");
+        dispatchCustomEvent("after-leave");
+      } else {
+        const isAnimating = prevAnimationName !== currentAnimationName;
+        if (prevPresent && isAnimating) {
+          dispatch("ANIMATION_OUT");
+          dispatchCustomEvent("leave");
+        } else {
+          dispatch("UNMOUNT");
+          dispatchCustomEvent("after-leave");
+        }
+      }
+    }
+  }, { immediate: true });
+  const handleAnimationEnd = (event) => {
+    const currentAnimationName = getAnimationName(node.value);
+    const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
+    const directionName = state.value === "mounted" ? "enter" : "leave";
+    if (event.target === node.value && isCurrentAnimation) {
+      dispatchCustomEvent(`after-${directionName}`);
+      dispatch("ANIMATION_END");
+      if (!prevPresentRef.value) {
+        const currentFillMode = node.value.style.animationFillMode;
+        node.value.style.animationFillMode = "forwards";
+        timeoutId = ownerWindow == null ? void 0 : ownerWindow.setTimeout(() => {
+          var _a2;
+          if (((_a2 = node.value) == null ? void 0 : _a2.style.animationFillMode) === "forwards") node.value.style.animationFillMode = currentFillMode;
+        });
+      }
+    }
+    if (event.target === node.value && currentAnimationName === "none") dispatch("ANIMATION_END");
+  };
+  const handleAnimationStart = (event) => {
+    if (event.target === node.value) prevAnimationNameRef.value = getAnimationName(node.value);
+  };
+  const watcher = watch(node, (newNode, oldNode) => {
+    if (newNode) {
+      stylesRef.value = getComputedStyle(newNode);
+      newNode.addEventListener("animationstart", handleAnimationStart);
+      newNode.addEventListener("animationcancel", handleAnimationEnd);
+      newNode.addEventListener("animationend", handleAnimationEnd);
+    } else {
+      dispatch("ANIMATION_END");
+      if (timeoutId !== void 0) ownerWindow == null ? void 0 : ownerWindow.clearTimeout(timeoutId);
+      oldNode == null ? void 0 : oldNode.removeEventListener("animationstart", handleAnimationStart);
+      oldNode == null ? void 0 : oldNode.removeEventListener("animationcancel", handleAnimationEnd);
+      oldNode == null ? void 0 : oldNode.removeEventListener("animationend", handleAnimationEnd);
+    }
+  }, { immediate: true });
+  const stateWatcher = watch(state, () => {
+    const currentAnimationName = getAnimationName(node.value);
+    prevAnimationNameRef.value = state.value === "mounted" ? currentAnimationName : "none";
+  });
+  onUnmounted(() => {
+    watcher();
+    stateWatcher();
+  });
+  const isPresent = computed(() => ["mounted", "unmountSuspended"].includes(state.value));
+  return { isPresent };
+}
+function getAnimationName(node) {
+  return node ? getComputedStyle(node).animationName || "none" : "none";
+}
+var Presence_default = defineComponent({
+  name: "Presence",
+  props: {
+    present: {
+      type: Boolean,
+      required: true
+    },
+    forceMount: { type: Boolean }
+  },
+  slots: {},
+  setup(props, { slots, expose }) {
+    var _a;
+    const { present, forceMount } = toRefs(props);
+    const node = ref();
+    const { isPresent } = usePresence(present, node);
+    expose({ present: isPresent });
+    let children = slots.default({ present: isPresent.value });
+    children = renderSlotFragments(children || []);
+    const instance = getCurrentInstance();
+    if (children && (children == null ? void 0 : children.length) > 1) {
+      const componentName = ((_a = instance == null ? void 0 : instance.parent) == null ? void 0 : _a.type.name) ? `<${instance.parent.type.name} />` : "component";
+      throw new Error([
+        `Detected an invalid children for \`${componentName}\` for  \`Presence\` component.`,
+        "",
+        "Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",
+        "You can apply a few solutions:",
+        ["Provide a single child element so that `presence` directive attach correctly.", "Ensure the first child is an actual element instead of a raw text node or comment node."].map((line) => `  - ${line}`).join("\n")
+      ].join("\n"));
+    }
+    return () => {
+      if (forceMount.value || present.value || isPresent.value) return h(slots.default({ present: isPresent.value })[0], { ref: (v) => {
+        const el = unrefElement(v);
+        if (typeof (el == null ? void 0 : el.hasAttribute) === "undefined") return el;
+        if (el == null ? void 0 : el.hasAttribute("data-reka-popper-content-wrapper")) node.value = el.firstElementChild;
+        else node.value = el;
+        return el;
+      } });
+      else return null;
+    };
+  }
+});
+export {
+  Presence_default as P,
+  useStateMachine as u
+};

package/dist/Progress.vue_vue_type_script_setup_true_lang-BDJfyW-d.js

@@ -0,0 +1,188 @@
+import { defineComponent, watch, nextTick, computed, openBlock, createBlock, unref, withCtx, renderSlot, mergeProps, createVNode, normalizeStyle } from "vue";
+import { c as createContext } from "./createContext-BabAT1K8.js";
+import { i as isNullish } from "./nullish-D3tMkl6i.js";
+import { u as useForwardExpose } from "./useForwardExpose-BcX3VRdS.js";
+import { P as Primitive } from "./Primitive-D3IcFg81.js";
+import { a as useVModel } from "./index-Dw56kNV0.js";
+import { c as cn } from "./utils-Bz4m9VPB.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
+const DEFAULT_MAX = 100;
+const [injectProgressRootContext, provideProgressRootContext] = createContext("ProgressRoot");
+const isNumber = (v) => typeof v === "number";
+function validateValue(value, max) {
+  const isValidValueError = isNullish(value) || isNumber(value) && !Number.isNaN(value) && value <= max && value >= 0;
+  if (isValidValueError) return value;
+  console.error(`Invalid prop \`value\` of value \`${value}\` supplied to \`ProgressRoot\`. The \`value\` prop must be:
+  - a positive number
+  - less than the value passed to \`max\` (or ${DEFAULT_MAX} if no \`max\` prop is set)
+  - \`null\`  or \`undefined\` if the progress is indeterminate.
+
+Defaulting to \`null\`.`);
+  return null;
+}
+function validateMax(max) {
+  const isValidMaxError = isNumber(max) && !Number.isNaN(max) && max > 0;
+  if (isValidMaxError) return max;
+  console.error(`Invalid prop \`max\` of value \`${max}\` supplied to \`ProgressRoot\`. Only numbers greater than 0 are valid max values. Defaulting to \`${DEFAULT_MAX}\`.`);
+  return DEFAULT_MAX;
+}
+var ProgressRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "ProgressRoot",
+  props: {
+    modelValue: {
+      type: [Number, null],
+      required: false
+    },
+    max: {
+      type: Number,
+      required: false,
+      default: DEFAULT_MAX
+    },
+    getValueLabel: {
+      type: Function,
+      required: false,
+      default: (value, max) => isNumber(value) ? `${Math.round(value / max * DEFAULT_MAX)}%` : void 0
+    },
+    getValueText: {
+      type: Function,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: ["update:modelValue", "update:max"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    useForwardExpose();
+    const modelValue = useVModel(props, "modelValue", emit, { passive: props.modelValue === void 0 });
+    const max = useVModel(props, "max", emit, { passive: props.max === void 0 });
+    watch(() => modelValue.value, async (value) => {
+      const correctedValue = validateValue(value, props.max);
+      if (correctedValue !== value) {
+        await nextTick();
+        modelValue.value = correctedValue;
+      }
+    }, { immediate: true });
+    watch(() => props.max, (newMax) => {
+      const correctedMax = validateMax(props.max);
+      if (correctedMax !== newMax) max.value = correctedMax;
+    }, { immediate: true });
+    const progressState = computed(() => {
+      if (isNullish(modelValue.value)) return "indeterminate";
+      if (modelValue.value === max.value) return "complete";
+      return "loading";
+    });
+    provideProgressRootContext({
+      modelValue,
+      max,
+      progressState
+    });
+    return (_ctx, _cache) => {
+      var _a;
+      return openBlock(), createBlock(unref(Primitive), {
+        "as-child": _ctx.asChild,
+        as: _ctx.as,
+        "aria-valuemax": unref(max),
+        "aria-valuemin": 0,
+        "aria-valuenow": isNumber(unref(modelValue)) ? unref(modelValue) : void 0,
+        "aria-valuetext": (_a = _ctx.getValueText) == null ? void 0 : _a.call(_ctx, unref(modelValue), unref(max)),
+        "aria-label": _ctx.getValueLabel(unref(modelValue), unref(max)),
+        role: "progressbar",
+        "data-state": progressState.value,
+        "data-value": unref(modelValue) ?? void 0,
+        "data-max": unref(max)
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) })]),
+        _: 3
+      }, 8, [
+        "as-child",
+        "as",
+        "aria-valuemax",
+        "aria-valuenow",
+        "aria-valuetext",
+        "aria-label",
+        "data-state",
+        "data-value",
+        "data-max"
+      ]);
+    };
+  }
+});
+var ProgressRoot_default = ProgressRoot_vue_vue_type_script_setup_true_lang_default;
+var ProgressIndicator_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "ProgressIndicator",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const rootContext = injectProgressRootContext();
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      var _a;
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+        "data-state": unref(rootContext).progressState.value,
+        "data-value": ((_a = unref(rootContext).modelValue) == null ? void 0 : _a.value) ?? void 0,
+        "data-max": unref(rootContext).max.value
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, [
+        "data-state",
+        "data-value",
+        "data-max"
+      ]);
+    };
+  }
+});
+var ProgressIndicator_default = ProgressIndicator_vue_vue_type_script_setup_true_lang_default;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Progress",
+  props: {
+    modelValue: { default: 0 },
+    max: {},
+    getValueLabel: {},
+    getValueText: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = reactiveOmit(props, "class");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ProgressRoot_default), mergeProps({ "data-slot": "progress" }, unref(delegatedProps), {
+        class: unref(cn)(
+          "bg-[var(--bg-selected-light)] dark:bg-[var(--bg-selected-dark)] relative h-2 w-full overflow-hidden",
+          props.class
+        )
+      }), {
+        default: withCtx(() => [
+          createVNode(unref(ProgressIndicator_default), {
+            "data-slot": "progress-indicator",
+            class: "bg-primary h-full w-full flex-1 transition-all",
+            style: normalizeStyle(`transform: translateX(-${100 - (props.modelValue ?? 0)}%);`)
+          }, null, 8, ["style"])
+        ]),
+        _: 1
+      }, 16, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/{Separator.vue_vue_type_script_setup_true_lang-CMRkdntA.js → Separator.vue_vue_type_script_setup_true_lang-D9BozdWD.js}

@@ -1,7 +1,7 @@
 import { defineComponent, openBlock, createBlock, unref, mergeProps } from "vue";
 import { S as Separator_default } from "./Separator-CFm_M4pb.js";
 import { c as cn } from "./utils-Bz4m9VPB.js";
-import { r as reactiveOmit } from "./index-qGMU40e1.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
 const _sfc_main = /* @__PURE__ */ defineComponent({
   __name: "Separator",
   props: {

package/dist/{SheetTitle.vue_vue_type_script_setup_true_lang-Csr3nKnG.js → SheetTitle.vue_vue_type_script_setup_true_lang-Ja7-gmXd.js}

@@ -1,11 +1,9 @@
-import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot, normalizeProps, guardReactiveProps, createVNode, createElementVNode, createElementBlock, normalizeClass } from "vue";
-import { u as useForwardPropsEmits } from "./useForwardPropsEmits-DmumnZO5.js";
-import { b as DialogRoot_default, D as DialogOverlay_default, a as DialogContent_default, c as DialogDescription_default, d as DialogTitle_default } from "./DialogTitle-CLuntLBB.js";
-import { H as HugeiconsIcon, a as dp } from "./HugeiconsIcon.vue-BJ-_Wtmk.js";
-import { D as DialogClose_default } from "./DialogClose-DDtZ0Em0.js";
-import { D as DialogPortal_default } from "./DialogPortal-D81oXsCY.js";
+import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot, normalizeProps, guardReactiveProps, createVNode, createElementBlock, normalizeClass } from "vue";
+import { u as useForwardPropsEmits } from "./useForwardPropsEmits-GlUGKcIz.js";
+import { b as DialogRoot_default, D as DialogOverlay_default, a as DialogContent_default, c as DialogDescription_default, d as DialogTitle_default } from "./DialogTitle-jKgSCoXM.js";
+import { D as DialogPortal_default } from "./DialogPortal-BiMJAKLg.js";
 import { c as cn } from "./utils-Bz4m9VPB.js";
-import { r as reactiveOmit } from "./index-qGMU40e1.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
 const _sfc_main$5 = /* @__PURE__ */ defineComponent({
   __name: "Sheet",
   props: {
@@ -87,17 +85,7 @@ const _sfc_main$3 = /* @__PURE__ */ defineComponent({
             )
           }, { ..._ctx.$attrs, ...unref(forwarded) }), {
             default: withCtx(() => [
-              renderSlot(_ctx.$slots, "default"),
-              createVNode(unref(DialogClose_default), { class: "ring-offset-background focus:ring-ring data-[state=open]:bg-secondary absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none" }, {
-                default: withCtx(() => [
-                  createVNode(unref(HugeiconsIcon), {
-                    icon: unref(dp),
-                    class: "size-4"
-                  }, null, 8, ["icon"]),
-                  _cache[0] || (_cache[0] = createElementVNode("span", { class: "sr-only" }, "Close", -1))
-                ]),
-                _: 1
-              })
+              renderSlot(_ctx.$slots, "default")
             ]),
             _: 3
           }, 16, ["class"])

package/dist/{Slider.vue_vue_type_script_setup_true_lang-C_CsSGAt.js → Slider.vue_vue_type_script_setup_true_lang-CSOSwGGr.js}

@@ -1,16 +1,17 @@
 import { defineComponent, toRefs, ref, computed, openBlock, createBlock, unref, normalizeStyle, withCtx, renderSlot, resolveDynamicComponent, mergeProps, createCommentVNode, toRaw, onMounted, onUnmounted, createVNode, createElementBlock, Fragment, renderList } from "vue";
-import { c as createContext, u as useForwardPropsEmits } from "./useForwardPropsEmits-DmumnZO5.js";
+import { u as useForwardPropsEmits } from "./useForwardPropsEmits-GlUGKcIz.js";
 import { c as clamp } from "./clamp-D5Ye0kJT.js";
-import { u as useDirection } from "./useDirection-SIyEYNxv.js";
-import { u as useFormControl } from "./useFormControl-CyoJwp9r.js";
-import { u as useForwardExpose } from "./useForwardExpose-BiRQH8eO.js";
-import { u as useCollection } from "./Collection-Coi6nyvb.js";
-import { V as VisuallyHiddenInput_default } from "./VisuallyHiddenInput-1G1IEkBL.js";
+import { c as createContext } from "./createContext-BabAT1K8.js";
+import { u as useDirection } from "./useDirection-B2bMgzzV.js";
+import { u as useFormControl } from "./useFormControl-DZ4LnB9F.js";
+import { u as useForwardExpose } from "./useForwardExpose-BcX3VRdS.js";
+import { u as useCollection } from "./Collection-4P3HQ4uU.js";
+import { V as VisuallyHiddenInput_default } from "./VisuallyHiddenInput-D5eipDQU.js";
 import { P as Primitive } from "./Primitive-D3IcFg81.js";
-import { u as useVModel, c as useMounted } from "./index-Cq9Ekgtb.js";
-import { u as useSize } from "./useSize-BLYTFgnQ.js";
+import { a as useVModel, b as useMounted } from "./index-Dw56kNV0.js";
+import { u as useSize } from "./useSize-DUgGY9t1.js";
 import { c as cn } from "./utils-Bz4m9VPB.js";
-import { r as reactiveOmit } from "./index-qGMU40e1.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
 function getNextSortedValues(prevValues = [], nextValue, atIndex) {
   const nextValues = [...prevValues];
   nextValues[atIndex] = nextValue;

package/dist/{Switch.vue_vue_type_script_setup_true_lang-BG6nkPSO.js → Switch.vue_vue_type_script_setup_true_lang-C8mqOepU.js}

@@ -1,12 +1,13 @@
 import { defineComponent, toRefs, computed, openBlock, createBlock, unref, mergeProps, withKeys, withModifiers, withCtx, renderSlot, createCommentVNode, createVNode, normalizeClass, normalizeProps, guardReactiveProps } from "vue";
-import { c as createContext, u as useForwardPropsEmits } from "./useForwardPropsEmits-DmumnZO5.js";
-import { u as useFormControl } from "./useFormControl-CyoJwp9r.js";
-import { u as useForwardExpose } from "./useForwardExpose-BiRQH8eO.js";
+import { u as useForwardPropsEmits } from "./useForwardPropsEmits-GlUGKcIz.js";
+import { c as createContext } from "./createContext-BabAT1K8.js";
+import { u as useFormControl } from "./useFormControl-DZ4LnB9F.js";
+import { u as useForwardExpose } from "./useForwardExpose-BcX3VRdS.js";
 import { P as Primitive } from "./Primitive-D3IcFg81.js";
-import { V as VisuallyHiddenInput_default } from "./VisuallyHiddenInput-1G1IEkBL.js";
-import { u as useVModel } from "./index-Cq9Ekgtb.js";
+import { V as VisuallyHiddenInput_default } from "./VisuallyHiddenInput-D5eipDQU.js";
+import { a as useVModel } from "./index-Dw56kNV0.js";
 import { c as cn } from "./utils-Bz4m9VPB.js";
-import { r as reactiveOmit } from "./index-qGMU40e1.js";
+import { r as reactiveOmit } from "./index-DDJjWaIl.js";
 const [injectSwitchRootContext, provideSwitchRootContext] = createContext("SwitchRoot");
 var SwitchRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
   __name: "SwitchRoot",