@eslamdevui/ui 4.1.1-rc.1 → 4.3.0

package/dist/runtime/types/html.d.ts

@@ -0,0 +1,8 @@
+import type { AnchorHTMLAttributes as VueAnchorHTMLAttributes, ButtonHTMLAttributes as VueButtonHTMLAttributes, FormHTMLAttributes as VueFormHTMLAttributes, ImgHTMLAttributes as VueImgHTMLAttributes, InputHTMLAttributes as VueInputHTMLAttributes, TableHTMLAttributes as VueTableHTMLAttributes, TextareaHTMLAttributes as VueTextareaHTMLAttributes } from 'vue';
+export type AnchorHTMLAttributes = Pick<VueAnchorHTMLAttributes, 'download' | 'href' | 'hreflang' | 'media' | 'ping' | 'rel' | 'target' | 'type' | 'referrerpolicy'>;
+export type ButtonHTMLAttributes = Pick<VueButtonHTMLAttributes, 'autofocus' | 'disabled' | 'form' | 'formaction' | 'formenctype' | 'formmethod' | 'formnovalidate' | 'formtarget' | 'name' | 'type'>;
+export type FormHTMLAttributes = Pick<VueFormHTMLAttributes, 'acceptcharset' | 'action' | 'autocomplete' | 'enctype' | 'method' | 'name' | 'novalidate' | 'target'>;
+export type ImgHTMLAttributes = Pick<VueImgHTMLAttributes, 'alt' | 'crossorigin' | 'decoding' | 'height' | 'loading' | 'referrerpolicy' | 'sizes' | 'src' | 'srcset' | 'usemap' | 'width'>;
+export type InputHTMLAttributes = Pick<VueInputHTMLAttributes, 'autocomplete' | 'autofocus' | 'disabled' | 'enterKeyHint' | 'form' | 'formaction' | 'formenctype' | 'formmethod' | 'formnovalidate' | 'formtarget' | 'list' | 'max' | 'maxlength' | 'min' | 'minlength' | 'name' | 'pattern' | 'placeholder' | 'readonly' | 'required' | 'size' | 'step' | 'type'>;
+export type TableHTMLAttributes = Pick<VueTableHTMLAttributes, 'cellpadding' | 'cellspacing' | 'summary' | 'width'>;
+export type TextareaHTMLAttributes = Pick<VueTextareaHTMLAttributes, 'autocomplete' | 'autofocus' | 'cols' | 'dirname' | 'disabled' | 'form' | 'maxlength' | 'minlength' | 'name' | 'placeholder' | 'readonly' | 'required' | 'rows' | 'wrap'>;

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

@@ -40,6 +40,12 @@ export * from '../components/DashboardSidebarToggle.vue';
 export * from '../components/DashboardToolbar.vue';
 export * from '../components/Drawer.vue';
 export * from '../components/DropdownMenu.vue';
+export * from '../components/Editor.vue';
+export * from '../components/EditorDragHandle.vue';
+export * from '../components/EditorEmojiMenu.vue';
+export * from '../components/EditorMentionMenu.vue';
+export * from '../components/EditorSuggestionMenu.vue';
+export * from '../components/EditorToolbar.vue';
 export * from '../components/Empty.vue';
 export * from '../components/Error.vue';
 export * from '../components/FieldGroup.vue';
@@ -51,9 +57,11 @@ export * from '../components/FormField.vue';
 export * from '../components/Header.vue';
 export * from '../components/Icon.vue';
 export * from '../components/Input.vue';
+export * from '../components/InputDate.vue';
 export * from '../components/InputMenu.vue';
 export * from '../components/InputNumber.vue';
 export * from '../components/InputTags.vue';
+export * from '../components/InputTime.vue';
 export * from '../components/Kbd.vue';
 export * from '../components/Link.vue';
 export * from '../components/Main.vue';
@@ -83,6 +91,7 @@ export * from '../components/PricingPlans.vue';
 export * from '../components/PricingTable.vue';
 export * from '../components/Progress.vue';
 export * from '../components/RadioGroup.vue';
+export * from '../components/ScrollArea.vue';
 export * from '../components/Select.vue';
 export * from '../components/SelectMenu.vue';
 export * from '../components/Separator.vue';
@@ -106,6 +115,10 @@ export * from '../components/color-mode/ColorModeImage.vue';
 export * from '../components/color-mode/ColorModeSelect.vue';
 export * from '../components/color-mode/ColorModeSwitch.vue';
 export * from '../components/locale/LocaleSelect.vue';
+export * from './content';
+export * from './editor';
 export * from './form';
 export * from './locale';
+export * from './prose';
 export * from './tv';
+export * from './utils';

package/dist/runtime/types/index.js

@@ -40,6 +40,12 @@ export * from "../components/DashboardSidebarToggle.vue";
 export * from "../components/DashboardToolbar.vue";
 export * from "../components/Drawer.vue";
 export * from "../components/DropdownMenu.vue";
+export * from "../components/Editor.vue";
+export * from "../components/EditorDragHandle.vue";
+export * from "../components/EditorEmojiMenu.vue";
+export * from "../components/EditorMentionMenu.vue";
+export * from "../components/EditorSuggestionMenu.vue";
+export * from "../components/EditorToolbar.vue";
 export * from "../components/Empty.vue";
 export * from "../components/Error.vue";
 export * from "../components/FieldGroup.vue";
@@ -51,9 +57,11 @@ export * from "../components/FormField.vue";
 export * from "../components/Header.vue";
 export * from "../components/Icon.vue";
 export * from "../components/Input.vue";
+export * from "../components/InputDate.vue";
 export * from "../components/InputMenu.vue";
 export * from "../components/InputNumber.vue";
 export * from "../components/InputTags.vue";
+export * from "../components/InputTime.vue";
 export * from "../components/Kbd.vue";
 export * from "../components/Link.vue";
 export * from "../components/Main.vue";
@@ -83,6 +91,7 @@ export * from "../components/PricingPlans.vue";
 export * from "../components/PricingTable.vue";
 export * from "../components/Progress.vue";
 export * from "../components/RadioGroup.vue";
+export * from "../components/ScrollArea.vue";
 export * from "../components/Select.vue";
 export * from "../components/SelectMenu.vue";
 export * from "../components/Separator.vue";
@@ -106,6 +115,10 @@ export * from "../components/color-mode/ColorModeImage.vue";
 export * from "../components/color-mode/ColorModeSelect.vue";
 export * from "../components/color-mode/ColorModeSwitch.vue";
 export * from "../components/locale/LocaleSelect.vue";
+export * from "./content.js";
+export * from "./editor.js";
 export * from "./form.js";
 export * from "./locale.js";
+export * from "./prose.js";
 export * from "./tv.js";
+export * from "./utils.js";

package/dist/runtime/types/input.d.ts

@@ -1,8 +1,8 @@
-export interface ModelModifiers {
-    string?: boolean;
-    number?: boolean;
-    trim?: boolean;
+export interface ModelModifiers<T = any> {
+    string?: string extends T ? boolean : never;
+    number?: number extends T ? boolean : never;
+    trim?: string extends T ? boolean : never;
     lazy?: boolean;
-    nullable?: boolean;
+    nullable?: null extends T ? boolean : never;
     optional?: boolean;
 }

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

@@ -42,4 +42,6 @@ export type StringOrVNode = string | VNode | (() => VNode);
 export type EmitsToProps<T> = {
     [K in keyof T as `on${Capitalize<string & K>}`]: T[K] extends [...args: infer Args] ? (...args: Args) => void : never;
 };
+export type NonUnion<T> = [T] extends [infer U] ? _NonUnion<U, U> : never;
+type _NonUnion<T, U> = U extends any ? [T] extends [U] ? unknown : never : never;
 export {};

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

@@ -0,0 +1,69 @@
+import type { Editor, Mark } from '@tiptap/vue-3';
+import type { Middleware } from '@floating-ui/dom';
+import type { EditorHandlers, EditorCustomHandlers, EditorItem, FloatingUIOptions } from '../types/editor';
+export declare function isMarkInSchema(mark: string | Mark, editor: Editor | null): boolean;
+export declare function isNodeTypeSelected(editor: Editor | null, nodeTypes: string[]): boolean;
+export declare function isExtensionAvailable(editor: Editor | null, extensionName: string): boolean;
+export declare function createToggleHandler(name: string): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createSetHandler(name: string): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createSimpleHandler(name: string): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: () => boolean;
+    isDisabled: undefined;
+};
+export declare function createMarkHandler(): {
+    canExecute: (editor: Editor, cmd: any) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor, cmd: any) => boolean;
+    isDisabled: (editor: Editor, cmd: any) => boolean;
+};
+export declare function createTextAlignHandler(): {
+    canExecute: (editor: Editor, cmd: any) => any;
+    execute: (editor: Editor, cmd: any) => any;
+    isActive: (editor: Editor, cmd: any) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createHeadingHandler(): {
+    canExecute: (editor: Editor, cmd: any) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor, cmd: any) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createLinkHandler(): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createImageHandler(): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createListHandler(listType: 'bulletList' | 'orderedList'): {
+    canExecute: (editor: Editor) => any;
+    execute: (editor: Editor) => any;
+    isActive: (editor: Editor) => boolean;
+    isDisabled: (editor: Editor) => boolean;
+};
+export declare function createMoveHandler(direction: 'up' | 'down'): {
+    canExecute: (editor: Editor, cmd: any) => boolean;
+    execute: (editor: Editor, cmd: any) => import("@tiptap/core").ChainedCommands;
+    isActive: () => boolean;
+    isDisabled: undefined;
+};
+export declare function createHandlers(): EditorHandlers;
+export declare function mapEditorItems(editor: Editor, items: (Partial<EditorItem> & Record<string, any>)[] | (Partial<EditorItem> & Record<string, any>)[][], customHandlers?: EditorCustomHandlers): any[] | any[][];
+export declare function buildFloatingUIMiddleware(options: FloatingUIOptions): Middleware[];

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

@@ -1,4 +1,5 @@
 import type { LinkProps } from '../types';
+export declare const linkKeys: readonly ["active", "activeClass", "ariaCurrentValue", "as", "disabled", "download", "exact", "exactActiveClass", "exactHash", "exactQuery", "external", "form", "formaction", "formenctype", "formmethod", "formnovalidate", "formtarget", "href", "hreflang", "inactiveClass", "media", "noPrefetch", "noRel", "onClick", "ping", "prefetch", "prefetchOn", "prefetchedClass", "referrerpolicy", "rel", "replace", "target", "title", "to", "trailingSlash", "type", "viewTransition"];
 export declare function pickLinkProps(link: LinkProps & {
     [key: string]: any;
 }): import("@vueuse/shared").ReactivePickReturn<LinkProps & {

package/dist/runtime/utils/link.js

@@ -1,34 +1,50 @@
 import { reactivePick } from "@vueuse/core";
 import { isEqual, diff } from "ohash/utils";
+export const linkKeys = [
+  "active",
+  "activeClass",
+  "ariaCurrentValue",
+  "as",
+  "disabled",
+  "download",
+  "exact",
+  "exactActiveClass",
+  "exactHash",
+  "exactQuery",
+  "external",
+  "form",
+  "formaction",
+  "formenctype",
+  "formmethod",
+  "formnovalidate",
+  "formtarget",
+  "href",
+  "hreflang",
+  "inactiveClass",
+  "media",
+  "noPrefetch",
+  "noRel",
+  "onClick",
+  "ping",
+  "prefetch",
+  "prefetchOn",
+  "prefetchedClass",
+  "referrerpolicy",
+  "rel",
+  "replace",
+  "target",
+  "title",
+  "to",
+  "trailingSlash",
+  "type",
+  "viewTransition"
+];
 export function pickLinkProps(link) {
   const keys = Object.keys(link);
   const ariaKeys = keys.filter((key) => key.startsWith("aria-"));
   const dataKeys = keys.filter((key) => key.startsWith("data-"));
   const propsToInclude = [
-    "active",
-    "activeClass",
-    "ariaCurrentValue",
-    "as",
-    "disabled",
-    "exact",
-    "exactActiveClass",
-    "exactHash",
-    "exactQuery",
-    "external",
-    "href",
-    "download",
-    "inactiveClass",
-    "noPrefetch",
-    "noRel",
-    "prefetch",
-    "prefetchedClass",
-    "rel",
-    "replace",
-    "target",
-    "to",
-    "type",
-    "title",
-    "onClick",
+    ...linkKeys,
     ...ariaKeys,
     ...dataKeys
   ];

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

@@ -0,0 +1,6 @@
+/**
+ * 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;