@brumaombra/ui-vintage 0.4.0 → 0.5.0

package/dist/tabs.js

@@ -0,0 +1,658 @@
+import { defineComponent, toRefs, ref, openBlock, createBlock, unref, withCtx, createVNode, renderSlot, computed, onMounted, onUnmounted, nextTick, shallowRef, onBeforeUnmount, normalizeStyle, createCommentVNode, withKeys, withModifiers, mergeProps, normalizeProps, guardReactiveProps } from "vue";
+import { u as useForwardPropsEmits, a as useForwardProps } from "./useForwardPropsEmits-GlUGKcIz.js";
+import { c as createContext } from "./createContext-BabAT1K8.js";
+import { u as useDirection } from "./useDirection-B2bMgzzV.js";
+import { u as useForwardExpose } from "./useForwardExpose-BcX3VRdS.js";
+import { u as useId } from "./useId-CF6wz41D.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";
+import { P as Presence_default } from "./Presence-CTmUEdMR.js";
+import { u as useCollection } from "./Collection-4P3HQ4uU.js";
+import { f as focusFirst, E as ENTRY_FOCUS, a as EVENT_OPTIONS, g as getFocusIntent, w as wrapArray } from "./utils-hdwtyAF3.js";
+const [injectRovingFocusGroupContext, provideRovingFocusGroupContext] = createContext("RovingFocusGroup");
+var RovingFocusGroup_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "RovingFocusGroup",
+  props: {
+    orientation: {
+      type: String,
+      required: false,
+      default: void 0
+    },
+    dir: {
+      type: String,
+      required: false
+    },
+    loop: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    currentTabStopId: {
+      type: [String, null],
+      required: false
+    },
+    defaultCurrentTabStopId: {
+      type: String,
+      required: false
+    },
+    preventScrollOnEntryFocus: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: ["entryFocus", "update:currentTabStopId"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { loop, orientation, dir: propDir } = toRefs(props);
+    const dir = useDirection(propDir);
+    const currentTabStopId = useVModel(props, "currentTabStopId", emits, {
+      defaultValue: props.defaultCurrentTabStopId,
+      passive: props.currentTabStopId === void 0
+    });
+    const isTabbingBackOut = ref(false);
+    const isClickFocus = ref(false);
+    const focusableItemsCount = ref(0);
+    const { getItems, CollectionSlot } = useCollection({ isProvider: true });
+    function handleFocus(event) {
+      const isKeyboardFocus = !isClickFocus.value;
+      if (event.currentTarget && event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut.value) {
+        const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);
+        event.currentTarget.dispatchEvent(entryFocusEvent);
+        emits("entryFocus", entryFocusEvent);
+        if (!entryFocusEvent.defaultPrevented) {
+          const items = getItems().map((i) => i.ref).filter((i) => i.dataset.disabled !== "");
+          const activeItem = items.find((item) => item.getAttribute("data-active") === "");
+          const highlightedItem = items.find((item) => item.getAttribute("data-highlighted") === "");
+          const currentItem = items.find((item) => item.id === currentTabStopId.value);
+          const candidateItems = [
+            activeItem,
+            highlightedItem,
+            currentItem,
+            ...items
+          ].filter(Boolean);
+          focusFirst(candidateItems, props.preventScrollOnEntryFocus);
+        }
+      }
+      isClickFocus.value = false;
+    }
+    function handleMouseUp() {
+      setTimeout(() => {
+        isClickFocus.value = false;
+      }, 1);
+    }
+    __expose({ getItems });
+    provideRovingFocusGroupContext({
+      loop,
+      dir,
+      orientation,
+      currentTabStopId,
+      onItemFocus: (tabStopId) => {
+        currentTabStopId.value = tabStopId;
+      },
+      onItemShiftTab: () => {
+        isTabbingBackOut.value = true;
+      },
+      onFocusableItemAdd: () => {
+        focusableItemsCount.value++;
+      },
+      onFocusableItemRemove: () => {
+        focusableItemsCount.value--;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(CollectionSlot), null, {
+        default: withCtx(() => [createVNode(unref(Primitive), {
+          tabindex: isTabbingBackOut.value || focusableItemsCount.value === 0 ? -1 : 0,
+          "data-orientation": unref(orientation),
+          as: _ctx.as,
+          "as-child": _ctx.asChild,
+          dir: unref(dir),
+          style: { "outline": "none" },
+          onMousedown: _cache[0] || (_cache[0] = ($event) => isClickFocus.value = true),
+          onMouseup: handleMouseUp,
+          onFocus: handleFocus,
+          onBlur: _cache[1] || (_cache[1] = ($event) => isTabbingBackOut.value = false)
+        }, {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 8, [
+          "tabindex",
+          "data-orientation",
+          "as",
+          "as-child",
+          "dir"
+        ])]),
+        _: 3
+      });
+    };
+  }
+});
+var RovingFocusGroup_default = RovingFocusGroup_vue_vue_type_script_setup_true_lang_default;
+var RovingFocusItem_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "RovingFocusItem",
+  props: {
+    tabStopId: {
+      type: String,
+      required: false
+    },
+    focusable: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    active: {
+      type: Boolean,
+      required: false
+    },
+    allowShiftKey: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "span"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const context = injectRovingFocusGroupContext();
+    const randomId = useId();
+    const id = computed(() => props.tabStopId || randomId);
+    const isCurrentTabStop = computed(() => context.currentTabStopId.value === id.value);
+    const { getItems, CollectionItem } = useCollection();
+    onMounted(() => {
+      if (props.focusable) context.onFocusableItemAdd();
+    });
+    onUnmounted(() => {
+      if (props.focusable) context.onFocusableItemRemove();
+    });
+    function handleKeydown(event) {
+      if (event.key === "Tab" && event.shiftKey) {
+        context.onItemShiftTab();
+        return;
+      }
+      if (event.target !== event.currentTarget) return;
+      const focusIntent = getFocusIntent(event, context.orientation.value, context.dir.value);
+      if (focusIntent !== void 0) {
+        if (event.metaKey || event.ctrlKey || event.altKey || (props.allowShiftKey ? false : event.shiftKey)) return;
+        event.preventDefault();
+        let candidateNodes = [...getItems().map((i) => i.ref).filter((i) => i.dataset.disabled !== "")];
+        if (focusIntent === "last") candidateNodes.reverse();
+        else if (focusIntent === "prev" || focusIntent === "next") {
+          if (focusIntent === "prev") candidateNodes.reverse();
+          const currentIndex = candidateNodes.indexOf(event.currentTarget);
+          candidateNodes = context.loop.value ? wrapArray(candidateNodes, currentIndex + 1) : candidateNodes.slice(currentIndex + 1);
+        }
+        nextTick(() => focusFirst(candidateNodes));
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(CollectionItem), null, {
+        default: withCtx(() => [createVNode(unref(Primitive), {
+          tabindex: isCurrentTabStop.value ? 0 : -1,
+          "data-orientation": unref(context).orientation.value,
+          "data-active": _ctx.active ? "" : void 0,
+          "data-disabled": !_ctx.focusable ? "" : void 0,
+          as: _ctx.as,
+          "as-child": _ctx.asChild,
+          onMousedown: _cache[0] || (_cache[0] = (event) => {
+            if (!_ctx.focusable) event.preventDefault();
+            else unref(context).onItemFocus(id.value);
+          }),
+          onFocus: _cache[1] || (_cache[1] = ($event) => unref(context).onItemFocus(id.value)),
+          onKeydown: handleKeydown
+        }, {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 8, [
+          "tabindex",
+          "data-orientation",
+          "data-active",
+          "data-disabled",
+          "as",
+          "as-child"
+        ])]),
+        _: 3
+      });
+    };
+  }
+});
+var RovingFocusItem_default = RovingFocusItem_vue_vue_type_script_setup_true_lang_default;
+const [injectTabsRootContext, provideTabsRootContext] = createContext("TabsRoot");
+var TabsRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "TabsRoot",
+  props: {
+    defaultValue: {
+      type: null,
+      required: false
+    },
+    orientation: {
+      type: String,
+      required: false,
+      default: "horizontal"
+    },
+    dir: {
+      type: String,
+      required: false
+    },
+    activationMode: {
+      type: String,
+      required: false,
+      default: "automatic"
+    },
+    modelValue: {
+      type: null,
+      required: false
+    },
+    unmountOnHide: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { orientation, unmountOnHide, dir: propDir } = toRefs(props);
+    const dir = useDirection(propDir);
+    useForwardExpose();
+    const modelValue = useVModel(props, "modelValue", emits, {
+      defaultValue: props.defaultValue,
+      passive: props.modelValue === void 0
+    });
+    const tabsList = ref();
+    const contentIds = shallowRef(/* @__PURE__ */ new Set());
+    provideTabsRootContext({
+      modelValue,
+      changeModelValue: (value) => {
+        modelValue.value = value;
+      },
+      orientation,
+      dir,
+      unmountOnHide,
+      activationMode: props.activationMode,
+      baseId: useId(void 0, "reka-tabs"),
+      tabsList,
+      contentIds,
+      registerContent: (value) => {
+        contentIds.value = /* @__PURE__ */ new Set([...contentIds.value, value]);
+      },
+      unregisterContent: (value) => {
+        const newSet = new Set(contentIds.value);
+        newSet.delete(value);
+        contentIds.value = newSet;
+      }
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        dir: unref(dir),
+        "data-orientation": unref(orientation),
+        "as-child": _ctx.asChild,
+        as: _ctx.as
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default", { modelValue: unref(modelValue) })]),
+        _: 3
+      }, 8, [
+        "dir",
+        "data-orientation",
+        "as-child",
+        "as"
+      ]);
+    };
+  }
+});
+var TabsRoot_default = TabsRoot_vue_vue_type_script_setup_true_lang_default;
+function makeTriggerId(baseId, value) {
+  return `${baseId}-trigger-${value}`;
+}
+function makeContentId(baseId, value) {
+  return `${baseId}-content-${value}`;
+}
+var TabsContent_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "TabsContent",
+  props: {
+    value: {
+      type: [String, Number],
+      required: true
+    },
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { forwardRef } = useForwardExpose();
+    const rootContext = injectTabsRootContext();
+    const triggerId = computed(() => makeTriggerId(rootContext.baseId, props.value));
+    const contentId = computed(() => makeContentId(rootContext.baseId, props.value));
+    const isSelected = computed(() => props.value === rootContext.modelValue.value);
+    const isMountAnimationPreventedRef = ref(isSelected.value);
+    onMounted(() => {
+      rootContext.registerContent(props.value);
+      requestAnimationFrame(() => {
+        isMountAnimationPreventedRef.value = false;
+      });
+    });
+    onBeforeUnmount(() => {
+      rootContext.unregisterContent(props.value);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Presence_default), {
+        present: _ctx.forceMount || isSelected.value,
+        "force-mount": ""
+      }, {
+        default: withCtx(({ present }) => [createVNode(unref(Primitive), {
+          id: contentId.value,
+          ref: unref(forwardRef),
+          "as-child": _ctx.asChild,
+          as: _ctx.as,
+          role: "tabpanel",
+          "data-state": isSelected.value ? "active" : "inactive",
+          "data-orientation": unref(rootContext).orientation.value,
+          "aria-labelledby": triggerId.value,
+          hidden: !present,
+          tabindex: "0",
+          style: normalizeStyle({ animationDuration: isMountAnimationPreventedRef.value ? "0s" : void 0 })
+        }, {
+          default: withCtx(() => [(unref(rootContext).unmountOnHide.value ? present : true) ? renderSlot(_ctx.$slots, "default", { key: 0 }) : createCommentVNode("v-if", true)]),
+          _: 2
+        }, 1032, [
+          "id",
+          "as-child",
+          "as",
+          "data-state",
+          "data-orientation",
+          "aria-labelledby",
+          "hidden",
+          "style"
+        ])]),
+        _: 3
+      }, 8, ["present"]);
+    };
+  }
+});
+var TabsContent_default = TabsContent_vue_vue_type_script_setup_true_lang_default;
+var TabsList_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "TabsList",
+  props: {
+    loop: {
+      type: Boolean,
+      required: false,
+      default: true
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { loop } = toRefs(props);
+    const { forwardRef, currentElement } = useForwardExpose();
+    const context = injectTabsRootContext();
+    context.tabsList = currentElement;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(RovingFocusGroup_default), {
+        "as-child": "",
+        orientation: unref(context).orientation.value,
+        dir: unref(context).dir.value,
+        loop: unref(loop)
+      }, {
+        default: withCtx(() => [createVNode(unref(Primitive), {
+          ref: unref(forwardRef),
+          role: "tablist",
+          "as-child": _ctx.asChild,
+          as: _ctx.as,
+          "aria-orientation": unref(context).orientation.value
+        }, {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 8, [
+          "as-child",
+          "as",
+          "aria-orientation"
+        ])]),
+        _: 3
+      }, 8, [
+        "orientation",
+        "dir",
+        "loop"
+      ]);
+    };
+  }
+});
+var TabsList_default = TabsList_vue_vue_type_script_setup_true_lang_default;
+var TabsTrigger_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "TabsTrigger",
+  props: {
+    value: {
+      type: [String, Number],
+      required: true
+    },
+    disabled: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "button"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { forwardRef } = useForwardExpose();
+    const rootContext = injectTabsRootContext();
+    const triggerId = computed(() => makeTriggerId(rootContext.baseId, props.value));
+    const contentId = computed(() => rootContext.contentIds.value.has(props.value) ? makeContentId(rootContext.baseId, props.value) : void 0);
+    const isSelected = computed(() => props.value === rootContext.modelValue.value);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(RovingFocusItem_default), {
+        "as-child": "",
+        focusable: !_ctx.disabled,
+        active: isSelected.value
+      }, {
+        default: withCtx(() => [createVNode(unref(Primitive), {
+          id: triggerId.value,
+          ref: unref(forwardRef),
+          role: "tab",
+          type: _ctx.as === "button" ? "button" : void 0,
+          as: _ctx.as,
+          "as-child": _ctx.asChild,
+          "aria-selected": isSelected.value ? "true" : "false",
+          "aria-controls": contentId.value,
+          "data-state": isSelected.value ? "active" : "inactive",
+          disabled: _ctx.disabled,
+          "data-disabled": _ctx.disabled ? "" : void 0,
+          "data-orientation": unref(rootContext).orientation.value,
+          onMousedown: _cache[0] || (_cache[0] = withModifiers((event) => {
+            if (!_ctx.disabled && event.ctrlKey === false) unref(rootContext).changeModelValue(_ctx.value);
+            else event.preventDefault();
+          }, ["left"])),
+          onKeydown: _cache[1] || (_cache[1] = withKeys(($event) => unref(rootContext).changeModelValue(_ctx.value), ["enter", "space"])),
+          onFocus: _cache[2] || (_cache[2] = () => {
+            const isAutomaticActivation = unref(rootContext).activationMode !== "manual";
+            if (!isSelected.value && !_ctx.disabled && isAutomaticActivation) unref(rootContext).changeModelValue(_ctx.value);
+          })
+        }, {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 8, [
+          "id",
+          "type",
+          "as",
+          "as-child",
+          "aria-selected",
+          "aria-controls",
+          "data-state",
+          "disabled",
+          "data-disabled",
+          "data-orientation"
+        ])]),
+        _: 3
+      }, 8, ["focusable", "active"]);
+    };
+  }
+});
+var TabsTrigger_default = TabsTrigger_vue_vue_type_script_setup_true_lang_default;
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  __name: "Tabs",
+  props: {
+    defaultValue: {},
+    orientation: {},
+    dir: {},
+    activationMode: {},
+    modelValue: {},
+    unmountOnHide: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const delegatedProps = reactiveOmit(props, "class");
+    const forwarded = useForwardPropsEmits(delegatedProps, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TabsRoot_default), mergeProps({ "data-slot": "tabs" }, unref(forwarded), {
+        class: unref(cn)("flex flex-col gap-2", props.class)
+      }), {
+        default: withCtx((slotProps) => [
+          renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps)))
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  __name: "TabsContent",
+  props: {
+    value: {},
+    forceMount: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = reactiveOmit(props, "class");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TabsContent_default), mergeProps({
+        "data-slot": "tabs-content",
+        class: unref(cn)("flex-1 outline-none", props.class)
+      }, unref(delegatedProps)), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "TabsList",
+  props: {
+    loop: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = reactiveOmit(props, "class");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TabsList_default), mergeProps({ "data-slot": "tabs-list" }, unref(delegatedProps), {
+        class: unref(cn)(
+          "inline-flex h-auto w-fit items-center justify-center gap-1 rounded border border-border bg-card p-1 text-card-foreground transition-colors duration-300 ease-in-out",
+          props.class
+        )
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TabsTrigger",
+  props: {
+    value: {},
+    disabled: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = reactiveOmit(props, "class");
+    const forwardedProps = useForwardProps(delegatedProps);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(TabsTrigger_default), mergeProps({
+        "data-slot": "tabs-trigger",
+        class: unref(cn)(
+          "text-muted-foreground hover:text-foreground focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring inline-flex min-h-9 flex-1 cursor-pointer items-center justify-center gap-1.5 rounded-sm border border-transparent bg-transparent px-4 py-2 text-sm font-medium whitespace-nowrap transition-colors duration-300 ease-in-out focus-visible:ring-[3px] focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:cursor-pointer data-[state=active]:border-foreground data-[state=active]:bg-muted data-[state=active]:font-semibold data-[state=active]:outline-1 data-[state=active]:outline-border data-[state=active]:outline-offset-0 data-[state=active]:shadow-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4",
+          props.class
+        )
+      }, unref(forwardedProps)), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main$3 as Tabs,
+  _sfc_main$2 as TabsContent,
+  _sfc_main$1 as TabsList,
+  _sfc_main as TabsTrigger
+};

package/dist/text-link.js

@@ -0,0 +1,39 @@
+import { defineComponent, openBlock, createBlock, resolveDynamicComponent, mergeProps, withCtx, createTextVNode, toDisplayString } from "vue";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "TextLink",
+  props: {
+    to: { type: String, required: true },
+    text: { type: String, required: true },
+    linkComponent: { type: [String, Object], default: "a" }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const getLinkProps = () => {
+      if (props.linkComponent === "a") {
+        return { href: props.to };
+      } else {
+        return { to: props.to };
+      }
+    };
+    const handleClick = (event) => {
+      emits("click", event);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(props.linkComponent), mergeProps(getLinkProps(), {
+        class: "cursor-pointer font-medium text-[var(--text-primary-light)] hover:underline dark:text-[var(--text-primary-dark)]",
+        onClick: handleClick
+      }), {
+        default: withCtx(() => [
+          createTextVNode(toDisplayString(props.text), 1)
+        ]),
+        _: 1
+      }, 16);
+    };
+  }
+});
+export {
+  _sfc_main as TextLink,
+  _sfc_main as default
+};