@nuxt/ui 4.2.1 → 4.4.0

package/dist/runtime/utils/editor.js

@@ -0,0 +1,382 @@
+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;
+      const hasCode = editor.isActive("code");
+      if (previousUrl) {
+        return chain.focus().unsetLink();
+      }
+      const href = cmd?.href || prompt("Enter the URL:");
+      if (!href) {
+        return chain;
+      }
+      if (hasCode) {
+        return chain.focus().extendMarkRange("code").setLink({ href });
+      }
+      return chain.focus().setLink({ href });
+    },
+    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 fnNameMap = {
+    bulletList: "toggleBulletList",
+    orderedList: "toggleOrderedList",
+    taskList: "toggleTaskList"
+  };
+  const fnName = fnNameMap[listType];
+  const listItemType = listType === "taskList" ? "taskItem" : "listItem";
+  return {
+    canExecute: (editor) => {
+      return editor.can()[fnName]() || editor.isActive("bulletList") || editor.isActive("orderedList") || editor.isActive("taskList") || editor.isActive("taskItem") || editor.isActive("listItem");
+    },
+    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(listItemType).lift("bulletList").lift("orderedList").lift("taskList").selectTextblockEnd();
+      }
+      const currentListItemType = editor.isActive("taskList") ? "taskItem" : "listItem";
+      if (editor.isActive("bulletList") || editor.isActive("orderedList") || editor.isActive("taskList")) {
+        const unwrapped = chain.liftListItem(currentListItemType).lift("bulletList").lift("orderedList").lift("taskList");
+        return unwrapped[fnName]().selectTextblockEnd();
+      }
+      return chain[fnName]().selectTextblockEnd();
+    },
+    isActive: (editor) => editor.isActive(listType),
+    isDisabled: (editor) => {
+      if (!isExtensionAvailable(editor, listType)) {
+        return true;
+      }
+      return 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"),
+    taskList: createListHandler("taskList"),
+    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/fuse.js

@@ -1,3 +1,22 @@
+const htmlEscapes = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHTML(str) {
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}
+function isAlreadyEscaped(str) {
+  return /&(?:amp|lt|gt|quot|#39);/.test(str);
+}
+function sanitize(str) {
+  if (isAlreadyEscaped(str)) {
+    return str;
+  }
+  return escapeHTML(str);
+}
 function truncateHTMLFromStart(html, maxLength) {
   let truncated = "";
   let totalLength = 0;
@@ -34,14 +53,14 @@ export function highlight(item, searchTerm, forceKey, omitKeys) {
       const lastIndiceNextIndex = region[1] + 1;
       const isMatched = lastIndiceNextIndex - region[0] >= searchTerm.length;
       content += [
-        value.substring(nextUnhighlightedRegionStartingIndex, region[0]),
+        sanitize(value.substring(nextUnhighlightedRegionStartingIndex, region[0])),
         isMatched && `<mark>`,
-        value.substring(region[0], lastIndiceNextIndex),
+        sanitize(value.substring(region[0], lastIndiceNextIndex)),
         isMatched && "</mark>"
       ].filter(Boolean).join("");
       nextUnhighlightedRegionStartingIndex = lastIndiceNextIndex;
     });
-    content += value.substring(nextUnhighlightedRegionStartingIndex);
+    content += sanitize(value.substring(nextUnhighlightedRegionStartingIndex));
     const markIndex = content.indexOf("<mark>");
     if (markIndex !== -1) {
       content = truncateHTMLFromStart(content, content.length - markIndex);

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

@@ -9,6 +9,7 @@ export declare function isEmpty(value: unknown): boolean;
 export declare function getDisplayValue<T extends Array<any>, V>(items: T, value: V | undefined | null, options?: {
     valueKey?: GetItemKeys<T>;
     labelKey?: GetItemKeys<T>;
+    by?: string | ((a: any, b: any) => boolean);
 }): string | undefined;
 export declare function isArrayOfArray<A>(item: A[] | A[][]): item is A[][];
 export declare function mergeClasses(appConfigClass?: string | string[], propClass?: string): "" | (string | undefined)[];

package/dist/runtime/utils/index.js

@@ -91,10 +91,10 @@ export function isEmpty(value) {
   return false;
 }
 export function getDisplayValue(items, value, options = {}) {
-  const { valueKey, labelKey } = options;
+  const { valueKey, labelKey, by } = options;
   const foundItem = items.find((item) => {
     const itemValue = typeof item === "object" && item !== null && valueKey ? get(item, valueKey) : item;
-    return compare(itemValue, value);
+    return compare(itemValue, value, by);
   });
   if (isEmpty(value) && foundItem) {
     return labelKey ? get(foundItem, labelKey) : void 0;

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/utils/virtualizer.d.ts

@@ -1,6 +1,4 @@
 /**
  * Get estimate size for virtualizers that checks each item individually
- * NOTE: This requires Reka UI to support functions for estimateSize (https://github.com/unovue/reka-ui/pull/2288)
- * Until then, we check if ANY item has a description and use that for all items
  */
-export declare function getEstimateSize(items: any[], size: 'xs' | 'sm' | 'md' | 'lg' | 'xl', descriptionKey?: string): number;
+export declare function getEstimateSize(items: any[], size: 'xs' | 'sm' | 'md' | 'lg' | 'xl', descriptionKey?: string, hasDescriptionSlot?: boolean): (index: number) => number;

package/dist/runtime/utils/virtualizer.js

@@ -1,13 +1,13 @@
 import { get } from "./index.js";
-function hasDescription(item, descriptionKey) {
+function itemHasDescription(item, descriptionKey) {
   if (typeof item !== "object" || item === null) {
     return false;
   }
   const value = get(item, descriptionKey);
   return value !== void 0 && value !== null && value !== "";
 }
-function getSize(size, hasDescription2) {
-  if (hasDescription2) {
+function getSize(size, hasDescription) {
+  if (hasDescription) {
     return {
       xs: 44,
       sm: 48,
@@ -24,7 +24,16 @@ function getSize(size, hasDescription2) {
     xl: 40
   }[size];
 }
-export function getEstimateSize(items, size, descriptionKey) {
-  const anyHasDescription = descriptionKey ? items.some((item) => hasDescription(item, descriptionKey)) : false;
-  return getSize(size, anyHasDescription);
+export function getEstimateSize(items, size, descriptionKey, hasDescriptionSlot) {
+  const sizeWithDescription = getSize(size, true);
+  const sizeWithoutDescription = getSize(size, false);
+  if (hasDescriptionSlot) {
+    return () => sizeWithDescription;
+  }
+  if (!descriptionKey) {
+    return () => sizeWithoutDescription;
+  }
+  return (index) => {
+    return itemHasDescription(items[index], descriptionKey) ? sizeWithDescription : sizeWithoutDescription;
+  };
 }

package/dist/runtime/vue/components/Icon.d.vue.ts

@@ -2,6 +2,6 @@ import type { IconProps as NuxtIconProps } from '../../types';
 export interface IconProps {
     name: NuxtIconProps['name'];
 }
-declare const __VLS_export: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/vue/components/Icon.vue.d.ts

@@ -2,6 +2,6 @@ import type { IconProps as NuxtIconProps } from '../../types';
 export interface IconProps {
     name: NuxtIconProps['name'];
 }
-declare const __VLS_export: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,8 +1,8 @@
 import type { SelectMenuProps, SelectMenuItem } from '../../../types';
 export interface ColorModeSelectProps extends Omit<SelectMenuProps<SelectMenuItem[]>, 'icon' | 'items' | 'modelValue'> {
 }
+declare const _default: typeof __VLS_export;
+export default _default;
 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 _default: typeof __VLS_export;
-export default _default;

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

@@ -19,6 +19,8 @@ const props = defineProps({
   required: { type: Boolean, required: false },
   trailingIcon: { type: null, required: false },
   selectedIcon: { type: null, required: false },
+  clear: { type: [Boolean, Object], required: false },
+  clearIcon: { type: null, required: false },
   content: { type: Object, required: false },
   arrow: { type: [Boolean, Object], required: false },
   portal: { type: [Boolean, String], required: false, skipCheck: true },
@@ -27,6 +29,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 },
@@ -42,7 +45,9 @@ const props = defineProps({
   name: { type: String, required: false },
   resetSearchTermOnBlur: { type: Boolean, required: false },
   resetSearchTermOnSelect: { type: Boolean, required: false },
+  resetModelValueOnClear: { type: Boolean, required: false },
   highlightOnHover: { type: Boolean, required: false },
+  by: { type: [String, Function], required: false },
   avatar: { type: Object, required: false },
   leading: { type: Boolean, required: false },
   leadingIcon: { type: null, required: false },

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

@@ -1,8 +1,8 @@
 import type { SelectMenuProps, SelectMenuItem } from '../../../types';
 export interface ColorModeSelectProps extends Omit<SelectMenuProps<SelectMenuItem[]>, 'icon' | 'items' | 'modelValue'> {
 }
+declare const _default: typeof __VLS_export;
+export default _default;
 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 _default: typeof __VLS_export;
-export default _default;

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

@@ -1,6 +1,6 @@
 import type { SwitchProps } from '../../../types';
 export interface ColorModeSwitchProps extends Omit<SwitchProps, 'checkedIcon' | 'uncheckedIcon' | 'modelValue'> {
 }
-declare const __VLS_export: import("vue").DefineComponent<ColorModeSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<ColorModeSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -1,6 +1,6 @@
 import type { SwitchProps } from '../../../types';
 export interface ColorModeSwitchProps extends Omit<SwitchProps, 'checkedIcon' | 'uncheckedIcon' | 'modelValue'> {
 }
-declare const __VLS_export: import("vue").DefineComponent<ColorModeSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;
+declare const __VLS_export: import("vue").DefineComponent<ColorModeSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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,14 +59,14 @@ export interface LinkSlots {
         active: boolean;
     }): any;
 }
+declare const _default: typeof __VLS_export;
+export default _default;
 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;
+    type: "reset" | "submit" | "button";
     active: boolean;
     ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
 }, {}, {}, {}, 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;

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,14 +59,14 @@ export interface LinkSlots {
         active: boolean;
     }): any;
 }
+declare const _default: typeof __VLS_export;
+export default _default;
 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;
+    type: "reset" | "submit" | "button";
     active: boolean;
     ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
 }, {}, {}, {}, 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;