@nuxt/ui 4.2.1 → 4.3.0

package/dist/runtime/utils/editor.js

@@ -0,0 +1,364 @@
+import { flip, shift, offset, size, autoPlacement, hide, inline } from "@floating-ui/dom";
+import { isArrayOfArray } from "./index.js";
+export function isMarkInSchema(mark, editor) {
+  if (!editor?.schema) {
+    return false;
+  }
+  const markName = typeof mark === "string" ? mark : mark.name;
+  return editor.schema.spec.marks.get(markName) !== void 0;
+}
+export function isNodeTypeSelected(editor, nodeTypes) {
+  if (!editor) {
+    return false;
+  }
+  const { selection } = editor.state;
+  const { $from, to } = selection;
+  return nodeTypes.some((nodeType) => {
+    return editor.state.doc.nodesBetween($from.pos, to, (node) => {
+      return node.type.name === nodeType;
+    });
+  });
+}
+export function isExtensionAvailable(editor, extensionName) {
+  if (!editor) {
+    return false;
+  }
+  return editor.extensionManager.extensions.some((ext) => ext.name === extensionName);
+}
+export function createToggleHandler(name) {
+  const fnName = `toggle${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+  return {
+    canExecute: (editor) => editor.can()[fnName](),
+    execute: (editor) => editor.chain().focus()[fnName](),
+    isActive: (editor) => editor.isActive(name),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createSetHandler(name) {
+  const fnName = `set${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+  return {
+    canExecute: (editor) => editor.can()[fnName](),
+    execute: (editor) => editor.chain().focus()[fnName](),
+    isActive: (editor) => editor.isActive(name),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createSimpleHandler(name) {
+  return {
+    canExecute: (editor) => editor.can()[name](),
+    execute: (editor) => editor.chain()[name](),
+    isActive: () => false,
+    isDisabled: void 0
+  };
+}
+export function createMarkHandler() {
+  return {
+    canExecute: (editor, cmd) => editor.can().toggleMark(cmd.mark),
+    execute: (editor, cmd) => editor.chain().focus().toggleMark(cmd.mark),
+    isActive: (editor, cmd) => editor.isActive(cmd.mark),
+    isDisabled: (editor, cmd) => !isMarkInSchema(cmd.mark, editor) || isNodeTypeSelected(editor, ["image"])
+  };
+}
+export function createTextAlignHandler() {
+  return {
+    canExecute: (editor, cmd) => editor.can().setTextAlign(cmd.align),
+    execute: (editor, cmd) => editor.chain().focus().setTextAlign(cmd.align),
+    isActive: (editor, cmd) => editor.isActive({ textAlign: cmd.align }),
+    isDisabled: (editor) => !isExtensionAvailable(editor, "textAlign") || isNodeTypeSelected(editor, ["image", "horizontalRule"])
+  };
+}
+export function createHeadingHandler() {
+  return {
+    canExecute: (editor, cmd) => editor.can().toggleHeading({ level: cmd.level }),
+    execute: (editor, cmd) => editor.chain().focus().toggleHeading({ level: cmd.level }),
+    isActive: (editor, cmd) => editor.isActive("heading", { level: cmd.level }),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createLinkHandler() {
+  return {
+    canExecute: (editor) => {
+      return editor.can().setLink({ href: "" }) || editor.can().unsetLink();
+    },
+    execute: (editor, cmd) => {
+      const chain = editor.chain();
+      const previousUrl = editor.getAttributes("link").href;
+      if (previousUrl) {
+        return chain.focus().unsetLink();
+      }
+      if (cmd?.href) {
+        return chain.focus().setLink({ href: cmd.href });
+      }
+      const href = prompt("Enter the URL:");
+      if (href) {
+        return chain.focus().setLink({ href });
+      }
+      return chain;
+    },
+    isActive: (editor) => editor.isActive("link"),
+    isDisabled: (editor) => {
+      if (!isExtensionAvailable(editor, "link") || isNodeTypeSelected(editor, ["image"])) {
+        return true;
+      }
+      const { selection } = editor.state;
+      return selection.empty && !editor.isActive("link");
+    }
+  };
+}
+export function createImageHandler() {
+  return {
+    canExecute: (editor) => {
+      return editor.can().setImage({ src: "" });
+    },
+    execute: (editor, cmd) => {
+      const chain = editor.chain().focus();
+      if (cmd?.src) {
+        return chain.setImage({ src: cmd.src });
+      }
+      const src = prompt("Enter the image URL:");
+      if (src) {
+        return chain.setImage({ src });
+      }
+      return chain;
+    },
+    isActive: (editor) => editor.isActive("image"),
+    isDisabled: (editor) => {
+      return !isExtensionAvailable(editor, "image");
+    }
+  };
+}
+export function createListHandler(listType) {
+  const fnName = listType === "bulletList" ? "toggleBulletList" : "toggleOrderedList";
+  return {
+    canExecute: (editor) => {
+      return editor.can()[fnName]() || editor.isActive("bulletList") || editor.isActive("orderedList");
+    },
+    execute: (editor) => {
+      const { state } = editor;
+      const { selection } = state;
+      let chain = editor.chain().focus();
+      if (selection.node) {
+        const node = selection.node;
+        const firstChild = node.firstChild?.firstChild;
+        const lastChild = node.lastChild?.lastChild;
+        const from = firstChild ? selection.from + firstChild.nodeSize : selection.from + 1;
+        const to = lastChild ? selection.to - lastChild.nodeSize : selection.to - 1;
+        chain = chain.setTextSelection({ from, to }).clearNodes();
+      }
+      if (editor.isActive(listType)) {
+        return chain.liftListItem("listItem").lift("bulletList").lift("orderedList").selectTextblockEnd();
+      }
+      return chain[fnName]().selectTextblockEnd();
+    },
+    isActive: (editor) => editor.isActive(listType),
+    isDisabled: (editor) => isNodeTypeSelected(editor, ["image"]) || editor.isActive("code")
+  };
+}
+export function createMoveHandler(direction) {
+  return {
+    canExecute: (editor, cmd) => {
+      if (cmd?.pos == null) return false;
+      const node = editor.state.doc.nodeAt(cmd.pos);
+      if (!node) return false;
+      const $pos = editor.state.doc.resolve(cmd.pos);
+      const parent = $pos.parent;
+      const index = $pos.index();
+      return direction === "up" ? index > 0 : index < parent.childCount - 1;
+    },
+    execute: (editor, cmd) => {
+      if (cmd?.pos == null) return editor.chain();
+      const node = editor.state.doc.nodeAt(cmd.pos);
+      if (!node) return editor.chain();
+      const $pos = editor.state.doc.resolve(cmd.pos);
+      const parent = $pos.parent;
+      const index = $pos.index();
+      if (direction === "up" && index > 0) {
+        const prevNode = parent.child(index - 1);
+        const targetPos = cmd.pos - prevNode.nodeSize;
+        return editor.chain().focus().deleteRange({ from: cmd.pos, to: cmd.pos + node.nodeSize }).insertContentAt(targetPos, node.toJSON());
+      }
+      if (direction === "down" && index < parent.childCount - 1) {
+        const nextNode = parent.child(index + 1);
+        const targetPos = cmd.pos + nextNode.nodeSize;
+        return editor.chain().focus().deleteRange({ from: cmd.pos, to: cmd.pos + node.nodeSize }).insertContentAt(targetPos, node.toJSON());
+      }
+      return editor.chain();
+    },
+    isActive: () => false,
+    isDisabled: void 0
+  };
+}
+export function createHandlers() {
+  return {
+    mark: createMarkHandler(),
+    textAlign: createTextAlignHandler(),
+    heading: createHeadingHandler(),
+    link: createLinkHandler(),
+    image: createImageHandler(),
+    blockquote: createToggleHandler("blockquote"),
+    bulletList: createListHandler("bulletList"),
+    orderedList: createListHandler("orderedList"),
+    codeBlock: createToggleHandler("codeBlock"),
+    horizontalRule: createSetHandler("horizontalRule"),
+    paragraph: createSetHandler("paragraph"),
+    undo: createSimpleHandler("undo"),
+    redo: createSimpleHandler("redo"),
+    clearFormatting: {
+      canExecute: (editor, cmd) => {
+        if (cmd?.pos != null) {
+          const node = editor.state.doc.nodeAt(cmd.pos);
+          return !!node;
+        }
+        return editor.can().clearNodes() || editor.can().unsetAllMarks();
+      },
+      execute: (editor, cmd) => {
+        if (cmd?.pos != null) {
+          const node = editor.state.doc.nodeAt(cmd.pos);
+          if (!node) return editor.chain();
+          const from = cmd.pos + 1;
+          const to = cmd.pos + node.nodeSize - 1;
+          return editor.chain().focus().setTextSelection({ from, to }).clearNodes().unsetAllMarks();
+        }
+        return editor.chain().focus().clearNodes().unsetAllMarks();
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    duplicate: {
+      canExecute: (editor, cmd) => {
+        if (cmd?.pos == null) return false;
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        return !!node;
+      },
+      execute: (editor, cmd) => {
+        if (cmd?.pos == null) return editor.chain();
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        if (!node) return editor.chain();
+        return editor.chain().focus().insertContentAt(cmd.pos + node.nodeSize, node.toJSON());
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    delete: {
+      canExecute: (editor, cmd) => {
+        if (cmd?.pos == null) return false;
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        return !!node;
+      },
+      execute: (editor, cmd) => {
+        if (cmd?.pos == null) return editor.chain();
+        const node = editor.state.doc.nodeAt(cmd.pos);
+        if (!node) return editor.chain();
+        return editor.chain().focus().deleteRange({ from: cmd.pos, to: cmd.pos + node.nodeSize });
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    moveUp: createMoveHandler("up"),
+    moveDown: createMoveHandler("down"),
+    suggestion: {
+      canExecute: () => true,
+      execute: (editor, cmd) => {
+        const { state } = editor;
+        const { selection } = state;
+        const { $from } = selection;
+        if (cmd?.pos !== void 0) {
+          const node = state.doc.nodeAt(cmd.pos);
+          if (node) {
+            const insertPos2 = cmd.pos + node.nodeSize;
+            return editor.chain().focus().insertContentAt(insertPos2, { type: "paragraph", content: [{ type: "text", text: "/" }] });
+          }
+        }
+        const currentNode = $from.node($from.depth);
+        const currentNodePos = $from.before($from.depth);
+        const insertPos = currentNodePos + currentNode.nodeSize;
+        return editor.chain().focus().insertContentAt(insertPos, { type: "paragraph", content: [{ type: "text", text: "/" }] });
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    mention: {
+      canExecute: () => true,
+      execute: (editor) => {
+        const { state } = editor;
+        const { selection } = state;
+        const { $from } = selection;
+        const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - 1), $from.parentOffset, void 0, " ");
+        const needsSpace = textBefore && textBefore !== " ";
+        return editor.chain().focus().insertContent(needsSpace ? " @" : "@");
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    },
+    emoji: {
+      canExecute: () => true,
+      execute: (editor) => {
+        const { state } = editor;
+        const { selection } = state;
+        const { $from } = selection;
+        const textBefore = $from.parent.textBetween(Math.max(0, $from.parentOffset - 1), $from.parentOffset, void 0, " ");
+        const needsSpace = textBefore && textBefore !== " ";
+        return editor.chain().focus().insertContent(needsSpace ? " :" : ":");
+      },
+      isActive: () => false,
+      isDisabled: void 0
+    }
+  };
+}
+export function mapEditorItems(editor, items, customHandlers) {
+  const handlers = { ...createHandlers(), ...customHandlers };
+  if (isArrayOfArray(items)) {
+    return items.map(
+      (group) => mapEditorItems(editor, group, customHandlers)
+    );
+  }
+  return items.filter(Boolean).map((item) => {
+    if ("type" in item) {
+      return item;
+    }
+    const { kind, children, ...rest } = item;
+    const processedChildren = children?.length ? mapEditorItems(editor, children, customHandlers) : void 0;
+    if (kind) {
+      const handler = handlers[kind];
+      if (!handler) {
+        return {
+          ...rest,
+          children: processedChildren
+        };
+      }
+      return {
+        ...rest,
+        children: processedChildren,
+        disabled: handler.isDisabled?.(editor, item) || !handler.canExecute(editor, item),
+        active: handler.isActive(editor, item),
+        onSelect: () => handler.execute(editor, item).run()
+      };
+    }
+    return { ...rest, children: processedChildren };
+  });
+}
+export function buildFloatingUIMiddleware(options) {
+  const middleware = [];
+  if (options.offset) {
+    middleware.push(offset(typeof options.offset !== "boolean" ? options.offset : void 0));
+  }
+  if (options.flip) {
+    middleware.push(flip(typeof options.flip !== "boolean" ? options.flip : void 0));
+  }
+  if (options.shift) {
+    middleware.push(shift(typeof options.shift !== "boolean" ? options.shift : void 0));
+  }
+  if (options.size) {
+    middleware.push(size(typeof options.size !== "boolean" ? options.size : void 0));
+  }
+  if (options.autoPlacement) {
+    middleware.push(autoPlacement(typeof options.autoPlacement !== "boolean" ? options.autoPlacement : void 0));
+  }
+  if (options.hide) {
+    middleware.push(hide(typeof options.hide !== "boolean" ? options.hide : void 0));
+  }
+  if (options.inline) {
+    middleware.push(inline(typeof options.inline !== "boolean" ? options.inline : void 0));
+  }
+  return middleware;
+}

package/dist/runtime/utils/locale.d.ts

@@ -1,6 +1,5 @@
-import type { Ref } from 'vue';
+import type { Ref, MaybeRef } from 'vue';
 import type { Locale, Direction } from '../types/locale';
-import type { MaybeRef } from '@vueuse/core';
 export type TranslatorOption = Record<string, string | number>;
 export type Translator = (path: string, option?: TranslatorOption) => string;
 export type LocaleContext<M> = {

package/dist/runtime/vue/components/color-mode/ColorModeSelect.d.vue.ts

@@ -1,8 +1,6 @@
 import type { SelectMenuProps, SelectMenuItem } from '../../../types';
 export interface ColorModeSelectProps extends Omit<SelectMenuProps<SelectMenuItem[]>, 'icon' | 'items' | 'modelValue'> {
 }
-declare const __VLS_export: import("vue").DefineComponent<ColorModeSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSelectProps> & Readonly<{}>, {
-    searchInput: boolean | import("../../../types").InputProps;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<ColorModeSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSelectProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/vue/components/color-mode/ColorModeSelect.vue

@@ -27,6 +27,7 @@ const props = defineProps({
   labelKey: { type: null, required: false },
   descriptionKey: { type: null, required: false },
   defaultValue: { type: null, required: false },
+  modelModifiers: { type: Object, required: false },
   multiple: { type: Boolean, required: false },
   highlight: { type: Boolean, required: false },
   createItem: { type: [Boolean, String, Object], required: false },

package/dist/runtime/vue/components/color-mode/ColorModeSelect.vue.d.ts

@@ -1,8 +1,6 @@
 import type { SelectMenuProps, SelectMenuItem } from '../../../types';
 export interface ColorModeSelectProps extends Omit<SelectMenuProps<SelectMenuItem[]>, 'icon' | 'items' | 'modelValue'> {
 }
-declare const __VLS_export: import("vue").DefineComponent<ColorModeSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSelectProps> & Readonly<{}>, {
-    searchInput: boolean | import("../../../types").InputProps;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<ColorModeSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSelectProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/{inertia/components → vue/overrides/inertia}/Link.d.vue.ts

@@ -1,5 +1,5 @@
 import type { InertiaLinkProps } from '@inertiajs/vue3';
-import type { ButtonHTMLAttributes, AnchorHTMLAttributes } from '../../types/html';
+import type { ButtonHTMLAttributes, AnchorHTMLAttributes } from '../../../types/html';
 export interface LinkProps extends Partial<Omit<InertiaLinkProps, 'href' | 'onClick'>>, /** @vue-ignore */ Omit<ButtonHTMLAttributes, 'type' | 'disabled'>, /** @vue-ignore */ Omit<AnchorHTMLAttributes, 'href' | 'target' | 'rel' | 'type'> {
     /**
      * The element or component this component should render as when not a link.
@@ -59,12 +59,7 @@ export interface LinkSlots {
         active: boolean;
     }): any;
 }
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
-    as: any;
-    active: boolean;
-    ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/{inertia/components → vue/overrides/inertia}/Link.vue

@@ -10,9 +10,9 @@ import { reactiveOmit } from "@vueuse/core";
 import { usePage } from "@inertiajs/vue3";
 import { hasProtocol } from "ufo";
 import { useAppConfig } from "#imports";
-import { tv } from "../../utils/tv";
-import { mergeClasses } from "../../utils";
-import ULinkBase from "../../components/LinkBase.vue";
+import { tv } from "../../../utils/tv";
+import { mergeClasses } from "../../../utils";
+import ULinkBase from "./LinkBase.vue";
 defineOptions({ inheritAttrs: false });
 const props = defineProps({
   as: { type: null, required: false, default: "button" },

package/dist/runtime/{inertia/components → vue/overrides/inertia}/Link.vue.d.ts

@@ -1,5 +1,5 @@
 import type { InertiaLinkProps } from '@inertiajs/vue3';
-import type { ButtonHTMLAttributes, AnchorHTMLAttributes } from '../../types/html';
+import type { ButtonHTMLAttributes, AnchorHTMLAttributes } from '../../../types/html';
 export interface LinkProps extends Partial<Omit<InertiaLinkProps, 'href' | 'onClick'>>, /** @vue-ignore */ Omit<ButtonHTMLAttributes, 'type' | 'disabled'>, /** @vue-ignore */ Omit<AnchorHTMLAttributes, 'href' | 'target' | 'rel' | 'type'> {
     /**
      * The element or component this component should render as when not a link.
@@ -59,12 +59,7 @@ export interface LinkSlots {
         active: boolean;
     }): any;
 }
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
-    type: "reset" | "submit" | "button";
-    as: any;
-    active: boolean;
-    ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
 declare const _default: typeof __VLS_export;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {

package/dist/runtime/{inertia/components → vue/overrides/inertia}/LinkBase.d.vue.ts

@@ -1,4 +1,4 @@
-import type { LinkProps } from '../../types';
+import type { LinkProps } from '../../../types';
 export interface LinkBaseProps {
     as?: string;
     type?: string;
@@ -10,10 +10,7 @@ export interface LinkBaseProps {
     active?: boolean;
     isExternal?: boolean;
 }
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {
-    type: string;
-    as: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 } & {
     default?: (props: {}) => any;

package/dist/runtime/{inertia/components → vue/overrides/inertia}/LinkBase.vue.d.ts

@@ -1,4 +1,4 @@
-import type { LinkProps } from '../../types';
+import type { LinkProps } from '../../../types';
 export interface LinkBaseProps {
     as?: string;
     type?: string;
@@ -10,10 +10,7 @@ export interface LinkBaseProps {
     active?: boolean;
     isExternal?: boolean;
 }
-declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {
-    type: string;
-    as: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkBaseProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkBaseProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
     default?: (props: {}) => any;
 } & {
     default?: (props: {}) => any;

package/dist/runtime/vue/overrides/none/Link.d.vue.ts

@@ -0,0 +1,71 @@
+import type { ButtonHTMLAttributes } from 'vue';
+interface BaseLinkProps {
+    /**
+     * Route Location the link should navigate to when clicked on.
+     */
+    to?: string;
+    /**
+     * An alias for `to`. If used with `to`, `href` will be ignored
+     */
+    href?: string;
+    /**
+     * Forces the link to be considered as external (true) or internal (false). This is helpful to handle edge-cases
+     */
+    external?: boolean;
+    /**
+     * Where to display the linked URL, as the name for a browsing context.
+     */
+    target?: '_blank' | '_parent' | '_self' | '_top' | (string & {}) | null;
+    /**
+     * A rel attribute value to apply on the link. Defaults to "noopener noreferrer" for external links.
+     */
+    rel?: 'noopener' | 'noreferrer' | 'nofollow' | 'sponsored' | 'ugc' | (string & {}) | null;
+    /**
+     * If set to true, no rel attribute will be added to the link
+     */
+    noRel?: boolean;
+}
+export interface LinkProps extends BaseLinkProps {
+    /**
+     * The element or component this component should render as when not a link.
+     * @defaultValue 'button'
+     */
+    as?: any;
+    /**
+     * The type of the button when not a link.
+     * @defaultValue 'button'
+     */
+    type?: ButtonHTMLAttributes['type'];
+    disabled?: boolean;
+    /** Force the link to be active independent of the current route. */
+    active?: boolean;
+    /** Will only be active if the current route is an exact match. */
+    exact?: boolean;
+    /** Allows controlling how the current route query sets the link as active. */
+    exactQuery?: boolean | 'partial';
+    /** Will only be active if the current route hash is an exact match. */
+    exactHash?: boolean;
+    /** The class to apply when the link is inactive. */
+    inactiveClass?: string;
+    /** The class to apply when the link is active. */
+    activeClass?: string;
+    /** The value of the `aria-current` attribute when the link is active. */
+    ariaCurrentValue?: string;
+    custom?: boolean;
+    /** When `true`, only styles from `class`, `activeClass`, and `inactiveClass` will be applied. */
+    raw?: boolean;
+    class?: any;
+}
+export interface LinkSlots {
+    default(props: {
+        active: boolean;
+    }): any;
+}
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};